@aws-sdk/client-ec2 3.121.0 → 3.130.0

package/dist-es/protocols/Aws_ec2.js

@@ -225,6 +225,16 @@ export var serializeAws_ec2AssociateTransitGatewayMulticastDomainCommand = funct
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2AssociateTransitGatewayPolicyTableCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2AssociateTransitGatewayPolicyTableRequest(input, context)), { Action: "AssociateTransitGatewayPolicyTable", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2AssociateTransitGatewayRouteTableCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -1045,6 +1055,16 @@ export var serializeAws_ec2CreateTransitGatewayPeeringAttachmentCommand = functi
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2CreateTransitGatewayPolicyTableCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2CreateTransitGatewayPolicyTableRequest(input, context)), { Action: "CreateTransitGatewayPolicyTable", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2CreateTransitGatewayPrefixListReferenceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -1075,6 +1095,16 @@ export var serializeAws_ec2CreateTransitGatewayRouteTableCommand = function (inp
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2CreateTransitGatewayRouteTableAnnouncementCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2CreateTransitGatewayRouteTableAnnouncementRequest(input, context)), { Action: "CreateTransitGatewayRouteTableAnnouncement", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2CreateTransitGatewayVpcAttachmentCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -1665,6 +1695,16 @@ export var serializeAws_ec2DeleteTransitGatewayPeeringAttachmentCommand = functi
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2DeleteTransitGatewayPolicyTableCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2DeleteTransitGatewayPolicyTableRequest(input, context)), { Action: "DeleteTransitGatewayPolicyTable", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2DeleteTransitGatewayPrefixListReferenceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -1695,6 +1735,16 @@ export var serializeAws_ec2DeleteTransitGatewayRouteTableCommand = function (inp
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2DeleteTransitGatewayRouteTableAnnouncementCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2DeleteTransitGatewayRouteTableAnnouncementRequest(input, context)), { Action: "DeleteTransitGatewayRouteTableAnnouncement", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2DeleteTransitGatewayVpcAttachmentCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -2985,6 +3035,26 @@ export var serializeAws_ec2DescribeTransitGatewayPeeringAttachmentsCommand = fun
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2DescribeTransitGatewayPolicyTablesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2DescribeTransitGatewayPolicyTablesRequest(input, context)), { Action: "DescribeTransitGatewayPolicyTables", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsRequest(input, context)), { Action: "DescribeTransitGatewayRouteTableAnnouncements", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2DescribeTransitGatewayRouteTablesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -3425,6 +3495,16 @@ export var serializeAws_ec2DisassociateTransitGatewayMulticastDomainCommand = fu
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2DisassociateTransitGatewayPolicyTableCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2DisassociateTransitGatewayPolicyTableRequest(input, context)), { Action: "DisassociateTransitGatewayPolicyTable", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2DisassociateTransitGatewayRouteTableCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -3905,6 +3985,26 @@ export var serializeAws_ec2GetTransitGatewayMulticastDomainAssociationsCommand =
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2GetTransitGatewayPolicyTableAssociationsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2GetTransitGatewayPolicyTableAssociationsRequest(input, context)), { Action: "GetTransitGatewayPolicyTableAssociations", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_ec2GetTransitGatewayPolicyTableEntriesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2GetTransitGatewayPolicyTableEntriesRequest(input, context)), { Action: "GetTransitGatewayPolicyTableEntries", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2GetTransitGatewayPrefixListReferencesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -6247,6 +6347,52 @@ var deserializeAws_ec2AssociateTransitGatewayMulticastDomainCommandError = funct
         }
     });
 }); };
+export var deserializeAws_ec2AssociateTransitGatewayPolicyTableCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2AssociateTransitGatewayPolicyTableCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2AssociateTransitGatewayPolicyTableResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2AssociateTransitGatewayPolicyTableCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
 export var deserializeAws_ec2AssociateTransitGatewayRouteTableCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -10019,25 +10165,25 @@ var deserializeAws_ec2CreateTransitGatewayPeeringAttachmentCommandError = functi
         }
     });
 }); };
-export var deserializeAws_ec2CreateTransitGatewayPrefixListReferenceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateTransitGatewayPolicyTableCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateTransitGatewayPrefixListReferenceCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateTransitGatewayPolicyTableCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateTransitGatewayPrefixListReferenceResult(data, context);
+                contents = deserializeAws_ec2CreateTransitGatewayPolicyTableResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateTransitGatewayPrefixListReferenceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateTransitGatewayPolicyTableCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10065,25 +10211,25 @@ var deserializeAws_ec2CreateTransitGatewayPrefixListReferenceCommandError = func
         }
     });
 }); };
-export var deserializeAws_ec2CreateTransitGatewayRouteCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateTransitGatewayPrefixListReferenceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateTransitGatewayRouteCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateTransitGatewayPrefixListReferenceCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateTransitGatewayRouteResult(data, context);
+                contents = deserializeAws_ec2CreateTransitGatewayPrefixListReferenceResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateTransitGatewayRouteCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateTransitGatewayPrefixListReferenceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10111,25 +10257,25 @@ var deserializeAws_ec2CreateTransitGatewayRouteCommandError = function (output,
         }
     });
 }); };
-export var deserializeAws_ec2CreateTransitGatewayRouteTableCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateTransitGatewayRouteCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateTransitGatewayRouteTableCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateTransitGatewayRouteCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateTransitGatewayRouteTableResult(data, context);
+                contents = deserializeAws_ec2CreateTransitGatewayRouteResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateTransitGatewayRouteTableCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateTransitGatewayRouteCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10157,25 +10303,25 @@ var deserializeAws_ec2CreateTransitGatewayRouteTableCommandError = function (out
         }
     });
 }); };
-export var deserializeAws_ec2CreateTransitGatewayVpcAttachmentCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateTransitGatewayRouteTableCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateTransitGatewayVpcAttachmentCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateTransitGatewayRouteTableCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateTransitGatewayVpcAttachmentResult(data, context);
+                contents = deserializeAws_ec2CreateTransitGatewayRouteTableResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateTransitGatewayVpcAttachmentCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateTransitGatewayRouteTableCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10203,25 +10349,25 @@ var deserializeAws_ec2CreateTransitGatewayVpcAttachmentCommandError = function (
         }
     });
 }); };
-export var deserializeAws_ec2CreateVolumeCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateTransitGatewayRouteTableAnnouncementCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVolumeCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateTransitGatewayRouteTableAnnouncementCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2Volume(data, context);
+                contents = deserializeAws_ec2CreateTransitGatewayRouteTableAnnouncementResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVolumeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateTransitGatewayRouteTableAnnouncementCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10249,25 +10395,25 @@ var deserializeAws_ec2CreateVolumeCommandError = function (output, context) { re
         }
     });
 }); };
-export var deserializeAws_ec2CreateVpcCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateTransitGatewayVpcAttachmentCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVpcCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateTransitGatewayVpcAttachmentCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateVpcResult(data, context);
+                contents = deserializeAws_ec2CreateTransitGatewayVpcAttachmentResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVpcCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateTransitGatewayVpcAttachmentCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10295,25 +10441,25 @@ var deserializeAws_ec2CreateVpcCommandError = function (output, context) { retur
         }
     });
 }); };
-export var deserializeAws_ec2CreateVpcEndpointCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateVolumeCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVpcEndpointCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVolumeCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateVpcEndpointResult(data, context);
+                contents = deserializeAws_ec2Volume(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVpcEndpointCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVolumeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10341,25 +10487,25 @@ var deserializeAws_ec2CreateVpcEndpointCommandError = function (output, context)
         }
     });
 }); };
-export var deserializeAws_ec2CreateVpcEndpointConnectionNotificationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateVpcCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVpcEndpointConnectionNotificationCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVpcCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateVpcEndpointConnectionNotificationResult(data, context);
+                contents = deserializeAws_ec2CreateVpcResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVpcEndpointConnectionNotificationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVpcCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10387,25 +10533,25 @@ var deserializeAws_ec2CreateVpcEndpointConnectionNotificationCommandError = func
         }
     });
 }); };
-export var deserializeAws_ec2CreateVpcEndpointServiceConfigurationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateVpcEndpointCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVpcEndpointServiceConfigurationCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVpcEndpointCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateVpcEndpointServiceConfigurationResult(data, context);
+                contents = deserializeAws_ec2CreateVpcEndpointResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVpcEndpointServiceConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVpcEndpointCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10433,25 +10579,25 @@ var deserializeAws_ec2CreateVpcEndpointServiceConfigurationCommandError = functi
         }
     });
 }); };
-export var deserializeAws_ec2CreateVpcPeeringConnectionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateVpcEndpointConnectionNotificationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVpcPeeringConnectionCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVpcEndpointConnectionNotificationCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateVpcPeeringConnectionResult(data, context);
+                contents = deserializeAws_ec2CreateVpcEndpointConnectionNotificationResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVpcPeeringConnectionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVpcEndpointConnectionNotificationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10479,25 +10625,25 @@ var deserializeAws_ec2CreateVpcPeeringConnectionCommandError = function (output,
         }
     });
 }); };
-export var deserializeAws_ec2CreateVpnConnectionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateVpcEndpointServiceConfigurationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVpnConnectionCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVpcEndpointServiceConfigurationCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateVpnConnectionResult(data, context);
+                contents = deserializeAws_ec2CreateVpcEndpointServiceConfigurationResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVpnConnectionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVpcEndpointServiceConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10525,25 +10671,25 @@ var deserializeAws_ec2CreateVpnConnectionCommandError = function (output, contex
         }
     });
 }); };
-export var deserializeAws_ec2CreateVpnConnectionRouteCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var response;
+export var deserializeAws_ec2CreateVpcPeeringConnectionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVpnConnectionRouteCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVpcPeeringConnectionCommandError(output, context)];
                 }
-                return [4, collectBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
-                _a.sent();
-                response = {
-                    $metadata: deserializeMetadata(output),
-                };
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2CreateVpcPeeringConnectionResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVpnConnectionRouteCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVpcPeeringConnectionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10571,25 +10717,25 @@ var deserializeAws_ec2CreateVpnConnectionRouteCommandError = function (output, c
         }
     });
 }); };
-export var deserializeAws_ec2CreateVpnGatewayCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateVpnConnectionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2CreateVpnGatewayCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVpnConnectionCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2CreateVpnGatewayResult(data, context);
+                contents = deserializeAws_ec2CreateVpnConnectionResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2CreateVpnGatewayCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVpnConnectionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10617,25 +10763,25 @@ var deserializeAws_ec2CreateVpnGatewayCommandError = function (output, context)
         }
     });
 }); };
-export var deserializeAws_ec2DeleteCarrierGatewayCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
+export var deserializeAws_ec2CreateVpnConnectionRouteCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2DeleteCarrierGatewayCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVpnConnectionRouteCommandError(output, context)];
                 }
-                return [4, parseBody(output.body, context)];
+                return [4, collectBody(output.body, context)];
             case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_ec2DeleteCarrierGatewayResult(data, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2DeleteCarrierGatewayCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVpnConnectionRouteCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10663,25 +10809,25 @@ var deserializeAws_ec2DeleteCarrierGatewayCommandError = function (output, conte
         }
     });
 }); };
-export var deserializeAws_ec2DeleteClientVpnEndpointCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2CreateVpnGatewayCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2DeleteClientVpnEndpointCommandError(output, context)];
+                    return [2, deserializeAws_ec2CreateVpnGatewayCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2DeleteClientVpnEndpointResult(data, context);
+                contents = deserializeAws_ec2CreateVpnGatewayResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2DeleteClientVpnEndpointCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2CreateVpnGatewayCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -10709,25 +10855,117 @@ var deserializeAws_ec2DeleteClientVpnEndpointCommandError = function (output, co
         }
     });
 }); };
-export var deserializeAws_ec2DeleteClientVpnRouteCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+export var deserializeAws_ec2DeleteCarrierGatewayCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2, deserializeAws_ec2DeleteClientVpnRouteCommandError(output, context)];
+                    return [2, deserializeAws_ec2DeleteCarrierGatewayCommandError(output, context)];
                 }
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
-                contents = deserializeAws_ec2DeleteClientVpnRouteResult(data, context);
+                contents = deserializeAws_ec2DeleteCarrierGatewayResult(data, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
                 return [2, Promise.resolve(response)];
         }
     });
 }); };
-var deserializeAws_ec2DeleteClientVpnRouteCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+var deserializeAws_ec2DeleteCarrierGatewayCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_ec2DeleteClientVpnEndpointCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2DeleteClientVpnEndpointCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2DeleteClientVpnEndpointResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2DeleteClientVpnEndpointCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_ec2DeleteClientVpnRouteCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2DeleteClientVpnRouteCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2DeleteClientVpnRouteResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2DeleteClientVpnRouteCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
     var _b;
     return __generator(this, function (_c) {
@@ -12871,6 +13109,52 @@ var deserializeAws_ec2DeleteTransitGatewayPeeringAttachmentCommandError = functi
         }
     });
 }); };
+export var deserializeAws_ec2DeleteTransitGatewayPolicyTableCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2DeleteTransitGatewayPolicyTableCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2DeleteTransitGatewayPolicyTableResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2DeleteTransitGatewayPolicyTableCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
 export var deserializeAws_ec2DeleteTransitGatewayPrefixListReferenceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -13009,6 +13293,52 @@ var deserializeAws_ec2DeleteTransitGatewayRouteTableCommandError = function (out
         }
     });
 }); };
+export var deserializeAws_ec2DeleteTransitGatewayRouteTableAnnouncementCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2DeleteTransitGatewayRouteTableAnnouncementCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2DeleteTransitGatewayRouteTableAnnouncementResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2DeleteTransitGatewayRouteTableAnnouncementCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
 export var deserializeAws_ec2DeleteTransitGatewayVpcAttachmentCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -18943,6 +19273,98 @@ var deserializeAws_ec2DescribeTransitGatewayPeeringAttachmentsCommandError = fun
         }
     });
 }); };
+export var deserializeAws_ec2DescribeTransitGatewayPolicyTablesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2DescribeTransitGatewayPolicyTablesCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2DescribeTransitGatewayPolicyTablesResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2DescribeTransitGatewayPolicyTablesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
 export var deserializeAws_ec2DescribeTransitGatewayRouteTablesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -20967,6 +21389,52 @@ var deserializeAws_ec2DisassociateTransitGatewayMulticastDomainCommandError = fu
         }
     });
 }); };
+export var deserializeAws_ec2DisassociateTransitGatewayPolicyTableCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2DisassociateTransitGatewayPolicyTableCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2DisassociateTransitGatewayPolicyTableResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2DisassociateTransitGatewayPolicyTableCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
 export var deserializeAws_ec2DisassociateTransitGatewayRouteTableCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -23175,6 +23643,98 @@ var deserializeAws_ec2GetTransitGatewayMulticastDomainAssociationsCommandError =
         }
     });
 }); };
+export var deserializeAws_ec2GetTransitGatewayPolicyTableAssociationsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2GetTransitGatewayPolicyTableAssociationsCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2GetTransitGatewayPolicyTableAssociationsResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2GetTransitGatewayPolicyTableAssociationsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_ec2GetTransitGatewayPolicyTableEntriesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2GetTransitGatewayPolicyTableEntriesCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2GetTransitGatewayPolicyTableEntriesResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2GetTransitGatewayPolicyTableEntriesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, $metadata, statusCode;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        $metadata = deserializeMetadata(output);
+                        statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode || statusCode || "UnknowError",
+                            $fault: "client",
+                            $metadata: $metadata,
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
 export var deserializeAws_ec2GetTransitGatewayPrefixListReferencesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -30079,6 +30639,19 @@ var serializeAws_ec2AssociateTransitGatewayMulticastDomainRequest = function (in
     }
     return entries;
 };
+var serializeAws_ec2AssociateTransitGatewayPolicyTableRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayPolicyTableId !== undefined && input.TransitGatewayPolicyTableId !== null) {
+        entries["TransitGatewayPolicyTableId"] = input.TransitGatewayPolicyTableId;
+    }
+    if (input.TransitGatewayAttachmentId !== undefined && input.TransitGatewayAttachmentId !== null) {
+        entries["TransitGatewayAttachmentId"] = input.TransitGatewayAttachmentId;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2AssociateTransitGatewayRouteTableRequest = function (input, context) {
     var entries = {};
     if (input.TransitGatewayRouteTableId !== undefined && input.TransitGatewayRouteTableId !== null) {
@@ -33089,6 +33662,14 @@ var serializeAws_ec2CreateTransitGatewayPeeringAttachmentRequest = function (inp
     if (input.PeerRegion !== undefined && input.PeerRegion !== null) {
         entries["PeerRegion"] = input.PeerRegion;
     }
+    if (input.Options !== undefined && input.Options !== null) {
+        var memberEntries = serializeAws_ec2CreateTransitGatewayPeeringAttachmentRequestOptions(input.Options, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Options.".concat(key);
+            entries[loc] = value;
+        });
+    }
     if (input.TagSpecifications !== undefined && input.TagSpecifications !== null) {
         var memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
         Object.entries(memberEntries).forEach(function (_a) {
@@ -33102,6 +33683,31 @@ var serializeAws_ec2CreateTransitGatewayPeeringAttachmentRequest = function (inp
     }
     return entries;
 };
+var serializeAws_ec2CreateTransitGatewayPeeringAttachmentRequestOptions = function (input, context) {
+    var entries = {};
+    if (input.DynamicRouting !== undefined && input.DynamicRouting !== null) {
+        entries["DynamicRouting"] = input.DynamicRouting;
+    }
+    return entries;
+};
+var serializeAws_ec2CreateTransitGatewayPolicyTableRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayId !== undefined && input.TransitGatewayId !== null) {
+        entries["TransitGatewayId"] = input.TransitGatewayId;
+    }
+    if (input.TagSpecifications !== undefined && input.TagSpecifications !== null) {
+        var memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "TagSpecifications.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2CreateTransitGatewayPrefixListReferenceRequest = function (input, context) {
     var entries = {};
     if (input.TransitGatewayRouteTableId !== undefined && input.TransitGatewayRouteTableId !== null) {
@@ -33166,6 +33772,27 @@ var serializeAws_ec2CreateTransitGatewayRouteRequest = function (input, context)
     }
     return entries;
 };
+var serializeAws_ec2CreateTransitGatewayRouteTableAnnouncementRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayRouteTableId !== undefined && input.TransitGatewayRouteTableId !== null) {
+        entries["TransitGatewayRouteTableId"] = input.TransitGatewayRouteTableId;
+    }
+    if (input.PeeringAttachmentId !== undefined && input.PeeringAttachmentId !== null) {
+        entries["PeeringAttachmentId"] = input.PeeringAttachmentId;
+    }
+    if (input.TagSpecifications !== undefined && input.TagSpecifications !== null) {
+        var memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "TagSpecification.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2CreateTransitGatewayRouteTableRequest = function (input, context) {
     var entries = {};
     if (input.TransitGatewayId !== undefined && input.TransitGatewayId !== null) {
@@ -34264,6 +34891,16 @@ var serializeAws_ec2DeleteTransitGatewayPeeringAttachmentRequest = function (inp
     }
     return entries;
 };
+var serializeAws_ec2DeleteTransitGatewayPolicyTableRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayPolicyTableId !== undefined && input.TransitGatewayPolicyTableId !== null) {
+        entries["TransitGatewayPolicyTableId"] = input.TransitGatewayPolicyTableId;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2DeleteTransitGatewayPrefixListReferenceRequest = function (input, context) {
     var entries = {};
     if (input.TransitGatewayRouteTableId !== undefined && input.TransitGatewayRouteTableId !== null) {
@@ -34300,6 +34937,17 @@ var serializeAws_ec2DeleteTransitGatewayRouteRequest = function (input, context)
     }
     return entries;
 };
+var serializeAws_ec2DeleteTransitGatewayRouteTableAnnouncementRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayRouteTableAnnouncementId !== undefined &&
+        input.TransitGatewayRouteTableAnnouncementId !== null) {
+        entries["TransitGatewayRouteTableAnnouncementId"] = input.TransitGatewayRouteTableAnnouncementId;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2DeleteTransitGatewayRouteTableRequest = function (input, context) {
     var entries = {};
     if (input.TransitGatewayRouteTableId !== undefined && input.TransitGatewayRouteTableId !== null) {
@@ -37553,6 +38201,65 @@ var serializeAws_ec2DescribeTransitGatewayPeeringAttachmentsRequest = function (
     }
     return entries;
 };
+var serializeAws_ec2DescribeTransitGatewayPolicyTablesRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayPolicyTableIds !== undefined && input.TransitGatewayPolicyTableIds !== null) {
+        var memberEntries = serializeAws_ec2TransitGatewayPolicyTableIdStringList(input.TransitGatewayPolicyTableIds, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "TransitGatewayPolicyTableIds.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.Filters !== undefined && input.Filters !== null) {
+        var memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Filter.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.MaxResults !== undefined && input.MaxResults !== null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.NextToken !== undefined && input.NextToken !== null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+var serializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayRouteTableAnnouncementIds !== undefined &&
+        input.TransitGatewayRouteTableAnnouncementIds !== null) {
+        var memberEntries = serializeAws_ec2TransitGatewayRouteTableAnnouncementIdStringList(input.TransitGatewayRouteTableAnnouncementIds, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "TransitGatewayRouteTableAnnouncementIds.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.Filters !== undefined && input.Filters !== null) {
+        var memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Filter.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.MaxResults !== undefined && input.MaxResults !== null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.NextToken !== undefined && input.NextToken !== null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2DescribeTransitGatewayRouteTablesRequest = function (input, context) {
     var entries = {};
     if (input.TransitGatewayRouteTableIds !== undefined && input.TransitGatewayRouteTableIds !== null) {
@@ -38278,6 +38985,10 @@ var serializeAws_ec2DisableTransitGatewayRouteTablePropagationRequest = function
     if (input.DryRun !== undefined && input.DryRun !== null) {
         entries["DryRun"] = input.DryRun;
     }
+    if (input.TransitGatewayRouteTableAnnouncementId !== undefined &&
+        input.TransitGatewayRouteTableAnnouncementId !== null) {
+        entries["TransitGatewayRouteTableAnnouncementId"] = input.TransitGatewayRouteTableAnnouncementId;
+    }
     return entries;
 };
 var serializeAws_ec2DisableVgwRoutePropagationRequest = function (input, context) {
@@ -38412,6 +39123,19 @@ var serializeAws_ec2DisassociateTransitGatewayMulticastDomainRequest = function
     }
     return entries;
 };
+var serializeAws_ec2DisassociateTransitGatewayPolicyTableRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayPolicyTableId !== undefined && input.TransitGatewayPolicyTableId !== null) {
+        entries["TransitGatewayPolicyTableId"] = input.TransitGatewayPolicyTableId;
+    }
+    if (input.TransitGatewayAttachmentId !== undefined && input.TransitGatewayAttachmentId !== null) {
+        entries["TransitGatewayAttachmentId"] = input.TransitGatewayAttachmentId;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2DisassociateTransitGatewayRouteTableRequest = function (input, context) {
     var entries = {};
     if (input.TransitGatewayRouteTableId !== undefined && input.TransitGatewayRouteTableId !== null) {
@@ -38821,6 +39545,10 @@ var serializeAws_ec2EnableTransitGatewayRouteTablePropagationRequest = function
     if (input.DryRun !== undefined && input.DryRun !== null) {
         entries["DryRun"] = input.DryRun;
     }
+    if (input.TransitGatewayRouteTableAnnouncementId !== undefined &&
+        input.TransitGatewayRouteTableAnnouncementId !== null) {
+        entries["TransitGatewayRouteTableAnnouncementId"] = input.TransitGatewayRouteTableAnnouncementId;
+    }
     return entries;
 };
 var serializeAws_ec2EnableVgwRoutePropagationRequest = function (input, context) {
@@ -39984,6 +40712,54 @@ var serializeAws_ec2GetTransitGatewayMulticastDomainAssociationsRequest = functi
     }
     return entries;
 };
+var serializeAws_ec2GetTransitGatewayPolicyTableAssociationsRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayPolicyTableId !== undefined && input.TransitGatewayPolicyTableId !== null) {
+        entries["TransitGatewayPolicyTableId"] = input.TransitGatewayPolicyTableId;
+    }
+    if (input.Filters !== undefined && input.Filters !== null) {
+        var memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Filter.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.MaxResults !== undefined && input.MaxResults !== null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.NextToken !== undefined && input.NextToken !== null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+var serializeAws_ec2GetTransitGatewayPolicyTableEntriesRequest = function (input, context) {
+    var entries = {};
+    if (input.TransitGatewayPolicyTableId !== undefined && input.TransitGatewayPolicyTableId !== null) {
+        entries["TransitGatewayPolicyTableId"] = input.TransitGatewayPolicyTableId;
+    }
+    if (input.Filters !== undefined && input.Filters !== null) {
+        var memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Filter.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.MaxResults !== undefined && input.MaxResults !== null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.NextToken !== undefined && input.NextToken !== null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2GetTransitGatewayPrefixListReferencesRequest = function (input, context) {
     var entries = {};
     if (input.TransitGatewayRouteTableId !== undefined && input.TransitGatewayRouteTableId !== null) {
@@ -44308,6 +45084,9 @@ var serializeAws_ec2ModifyTransitGatewayOptions = function (input, context) {
     if (input.PropagationDefaultRouteTableId !== undefined && input.PropagationDefaultRouteTableId !== null) {
         entries["PropagationDefaultRouteTableId"] = input.PropagationDefaultRouteTableId;
     }
+    if (input.AmazonSideAsn !== undefined && input.AmazonSideAsn !== null) {
+        entries["AmazonSideAsn"] = input.AmazonSideAsn;
+    }
     return entries;
 };
 var serializeAws_ec2ModifyTransitGatewayPrefixListReferenceRequest = function (input, context) {
@@ -49988,6 +50767,29 @@ var serializeAws_ec2TransitGatewayNetworkInterfaceIdList = function (input, cont
     }
     return entries;
 };
+var serializeAws_ec2TransitGatewayPolicyTableIdStringList = function (input, context) {
+    var e_199, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_199 = __values(input), input_199_1 = input_199.next(); !input_199_1.done; input_199_1 = input_199.next()) {
+            var entry = input_199_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["Item.".concat(counter)] = entry;
+            counter++;
+        }
+    }
+    catch (e_199_1) { e_199 = { error: e_199_1 }; }
+    finally {
+        try {
+            if (input_199_1 && !input_199_1.done && (_a = input_199.return)) _a.call(input_199);
+        }
+        finally { if (e_199) throw e_199.error; }
+    }
+    return entries;
+};
 var serializeAws_ec2TransitGatewayRequestOptions = function (input, context) {
     var entries = {};
     if (input.AmazonSideAsn !== undefined && input.AmazonSideAsn !== null) {
@@ -50021,13 +50823,36 @@ var serializeAws_ec2TransitGatewayRequestOptions = function (input, context) {
     }
     return entries;
 };
+var serializeAws_ec2TransitGatewayRouteTableAnnouncementIdStringList = function (input, context) {
+    var e_200, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_200 = __values(input), input_200_1 = input_200.next(); !input_200_1.done; input_200_1 = input_200.next()) {
+            var entry = input_200_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["Item.".concat(counter)] = entry;
+            counter++;
+        }
+    }
+    catch (e_200_1) { e_200 = { error: e_200_1 }; }
+    finally {
+        try {
+            if (input_200_1 && !input_200_1.done && (_a = input_200.return)) _a.call(input_200);
+        }
+        finally { if (e_200) throw e_200.error; }
+    }
+    return entries;
+};
 var serializeAws_ec2TransitGatewayRouteTableIdStringList = function (input, context) {
-    var e_199, _a;
+    var e_201, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_199 = __values(input), input_199_1 = input_199.next(); !input_199_1.done; input_199_1 = input_199.next()) {
-            var entry = input_199_1.value;
+        for (var input_201 = __values(input), input_201_1 = input_201.next(); !input_201_1.done; input_201_1 = input_201.next()) {
+            var entry = input_201_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50035,22 +50860,22 @@ var serializeAws_ec2TransitGatewayRouteTableIdStringList = function (input, cont
             counter++;
         }
     }
-    catch (e_199_1) { e_199 = { error: e_199_1 }; }
+    catch (e_201_1) { e_201 = { error: e_201_1 }; }
     finally {
         try {
-            if (input_199_1 && !input_199_1.done && (_a = input_199.return)) _a.call(input_199);
+            if (input_201_1 && !input_201_1.done && (_a = input_201.return)) _a.call(input_201);
         }
-        finally { if (e_199) throw e_199.error; }
+        finally { if (e_201) throw e_201.error; }
     }
     return entries;
 };
 var serializeAws_ec2TransitGatewaySubnetIdList = function (input, context) {
-    var e_200, _a;
+    var e_202, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_200 = __values(input), input_200_1 = input_200.next(); !input_200_1.done; input_200_1 = input_200.next()) {
-            var entry = input_200_1.value;
+        for (var input_202 = __values(input), input_202_1 = input_202.next(); !input_202_1.done; input_202_1 = input_202.next()) {
+            var entry = input_202_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50058,22 +50883,22 @@ var serializeAws_ec2TransitGatewaySubnetIdList = function (input, context) {
             counter++;
         }
     }
-    catch (e_200_1) { e_200 = { error: e_200_1 }; }
+    catch (e_202_1) { e_202 = { error: e_202_1 }; }
     finally {
         try {
-            if (input_200_1 && !input_200_1.done && (_a = input_200.return)) _a.call(input_200);
+            if (input_202_1 && !input_202_1.done && (_a = input_202.return)) _a.call(input_202);
         }
-        finally { if (e_200) throw e_200.error; }
+        finally { if (e_202) throw e_202.error; }
     }
     return entries;
 };
 var serializeAws_ec2TrunkInterfaceAssociationIdList = function (input, context) {
-    var e_201, _a;
+    var e_203, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_201 = __values(input), input_201_1 = input_201.next(); !input_201_1.done; input_201_1 = input_201.next()) {
-            var entry = input_201_1.value;
+        for (var input_203 = __values(input), input_203_1 = input_203.next(); !input_203_1.done; input_203_1 = input_203.next()) {
+            var entry = input_203_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50081,12 +50906,12 @@ var serializeAws_ec2TrunkInterfaceAssociationIdList = function (input, context)
             counter++;
         }
     }
-    catch (e_201_1) { e_201 = { error: e_201_1 }; }
+    catch (e_203_1) { e_203 = { error: e_203_1 }; }
     finally {
         try {
-            if (input_201_1 && !input_201_1.done && (_a = input_201.return)) _a.call(input_201);
+            if (input_203_1 && !input_203_1.done && (_a = input_203.return)) _a.call(input_203);
         }
-        finally { if (e_201) throw e_201.error; }
+        finally { if (e_203) throw e_203.error; }
     }
     return entries;
 };
@@ -50227,12 +51052,12 @@ var serializeAws_ec2UserData = function (input, context) {
     return entries;
 };
 var serializeAws_ec2UserGroupStringList = function (input, context) {
-    var e_202, _a;
+    var e_204, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_202 = __values(input), input_202_1 = input_202.next(); !input_202_1.done; input_202_1 = input_202.next()) {
-            var entry = input_202_1.value;
+        for (var input_204 = __values(input), input_204_1 = input_204.next(); !input_204_1.done; input_204_1 = input_204.next()) {
+            var entry = input_204_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50240,12 +51065,12 @@ var serializeAws_ec2UserGroupStringList = function (input, context) {
             counter++;
         }
     }
-    catch (e_202_1) { e_202 = { error: e_202_1 }; }
+    catch (e_204_1) { e_204 = { error: e_204_1 }; }
     finally {
         try {
-            if (input_202_1 && !input_202_1.done && (_a = input_202.return)) _a.call(input_202);
+            if (input_204_1 && !input_204_1.done && (_a = input_204.return)) _a.call(input_204);
         }
-        finally { if (e_202) throw e_202.error; }
+        finally { if (e_204) throw e_204.error; }
     }
     return entries;
 };
@@ -50275,12 +51100,12 @@ var serializeAws_ec2UserIdGroupPair = function (input, context) {
     return entries;
 };
 var serializeAws_ec2UserIdGroupPairList = function (input, context) {
-    var e_203, _a;
+    var e_205, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_203 = __values(input), input_203_1 = input_203.next(); !input_203_1.done; input_203_1 = input_203.next()) {
-            var entry = input_203_1.value;
+        for (var input_205 = __values(input), input_205_1 = input_205.next(); !input_205_1.done; input_205_1 = input_205.next()) {
+            var entry = input_205_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50292,22 +51117,22 @@ var serializeAws_ec2UserIdGroupPairList = function (input, context) {
             counter++;
         }
     }
-    catch (e_203_1) { e_203 = { error: e_203_1 }; }
+    catch (e_205_1) { e_205 = { error: e_205_1 }; }
     finally {
         try {
-            if (input_203_1 && !input_203_1.done && (_a = input_203.return)) _a.call(input_203);
+            if (input_205_1 && !input_205_1.done && (_a = input_205.return)) _a.call(input_205);
         }
-        finally { if (e_203) throw e_203.error; }
+        finally { if (e_205) throw e_205.error; }
     }
     return entries;
 };
 var serializeAws_ec2UserIdStringList = function (input, context) {
-    var e_204, _a;
+    var e_206, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_204 = __values(input), input_204_1 = input_204.next(); !input_204_1.done; input_204_1 = input_204.next()) {
-            var entry = input_204_1.value;
+        for (var input_206 = __values(input), input_206_1 = input_206.next(); !input_206_1.done; input_206_1 = input_206.next()) {
+            var entry = input_206_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50315,22 +51140,22 @@ var serializeAws_ec2UserIdStringList = function (input, context) {
             counter++;
         }
     }
-    catch (e_204_1) { e_204 = { error: e_204_1 }; }
+    catch (e_206_1) { e_206 = { error: e_206_1 }; }
     finally {
         try {
-            if (input_204_1 && !input_204_1.done && (_a = input_204.return)) _a.call(input_204);
+            if (input_206_1 && !input_206_1.done && (_a = input_206.return)) _a.call(input_206);
         }
-        finally { if (e_204) throw e_204.error; }
+        finally { if (e_206) throw e_206.error; }
     }
     return entries;
 };
 var serializeAws_ec2ValueStringList = function (input, context) {
-    var e_205, _a;
+    var e_207, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_205 = __values(input), input_205_1 = input_205.next(); !input_205_1.done; input_205_1 = input_205.next()) {
-            var entry = input_205_1.value;
+        for (var input_207 = __values(input), input_207_1 = input_207.next(); !input_207_1.done; input_207_1 = input_207.next()) {
+            var entry = input_207_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50338,12 +51163,12 @@ var serializeAws_ec2ValueStringList = function (input, context) {
             counter++;
         }
     }
-    catch (e_205_1) { e_205 = { error: e_205_1 }; }
+    catch (e_207_1) { e_207 = { error: e_207_1 }; }
     finally {
         try {
-            if (input_205_1 && !input_205_1.done && (_a = input_205.return)) _a.call(input_205);
+            if (input_207_1 && !input_207_1.done && (_a = input_207.return)) _a.call(input_207);
         }
-        finally { if (e_205) throw e_205.error; }
+        finally { if (e_207) throw e_207.error; }
     }
     return entries;
 };
@@ -50368,59 +51193,6 @@ var serializeAws_ec2VCpuCountRangeRequest = function (input, context) {
     return entries;
 };
 var serializeAws_ec2VersionStringList = function (input, context) {
-    var e_206, _a;
-    var entries = {};
-    var counter = 1;
-    try {
-        for (var input_206 = __values(input), input_206_1 = input_206.next(); !input_206_1.done; input_206_1 = input_206.next()) {
-            var entry = input_206_1.value;
-            if (entry === null) {
-                continue;
-            }
-            entries["Item.".concat(counter)] = entry;
-            counter++;
-        }
-    }
-    catch (e_206_1) { e_206 = { error: e_206_1 }; }
-    finally {
-        try {
-            if (input_206_1 && !input_206_1.done && (_a = input_206.return)) _a.call(input_206);
-        }
-        finally { if (e_206) throw e_206.error; }
-    }
-    return entries;
-};
-var serializeAws_ec2VirtualizationTypeSet = function (input, context) {
-    var e_207, _a;
-    var entries = {};
-    var counter = 1;
-    try {
-        for (var input_207 = __values(input), input_207_1 = input_207.next(); !input_207_1.done; input_207_1 = input_207.next()) {
-            var entry = input_207_1.value;
-            if (entry === null) {
-                continue;
-            }
-            entries["Item.".concat(counter)] = entry;
-            counter++;
-        }
-    }
-    catch (e_207_1) { e_207 = { error: e_207_1 }; }
-    finally {
-        try {
-            if (input_207_1 && !input_207_1.done && (_a = input_207.return)) _a.call(input_207);
-        }
-        finally { if (e_207) throw e_207.error; }
-    }
-    return entries;
-};
-var serializeAws_ec2VolumeDetail = function (input, context) {
-    var entries = {};
-    if (input.Size !== undefined && input.Size !== null) {
-        entries["Size"] = input.Size;
-    }
-    return entries;
-};
-var serializeAws_ec2VolumeIdStringList = function (input, context) {
     var e_208, _a;
     var entries = {};
     var counter = 1;
@@ -50430,7 +51202,7 @@ var serializeAws_ec2VolumeIdStringList = function (input, context) {
             if (entry === null) {
                 continue;
             }
-            entries["VolumeId.".concat(counter)] = entry;
+            entries["Item.".concat(counter)] = entry;
             counter++;
         }
     }
@@ -50443,7 +51215,7 @@ var serializeAws_ec2VolumeIdStringList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpcClassicLinkIdList = function (input, context) {
+var serializeAws_ec2VirtualizationTypeSet = function (input, context) {
     var e_209, _a;
     var entries = {};
     var counter = 1;
@@ -50453,7 +51225,7 @@ var serializeAws_ec2VpcClassicLinkIdList = function (input, context) {
             if (entry === null) {
                 continue;
             }
-            entries["VpcId.".concat(counter)] = entry;
+            entries["Item.".concat(counter)] = entry;
             counter++;
         }
     }
@@ -50466,7 +51238,14 @@ var serializeAws_ec2VpcClassicLinkIdList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpcEndpointIdList = function (input, context) {
+var serializeAws_ec2VolumeDetail = function (input, context) {
+    var entries = {};
+    if (input.Size !== undefined && input.Size !== null) {
+        entries["Size"] = input.Size;
+    }
+    return entries;
+};
+var serializeAws_ec2VolumeIdStringList = function (input, context) {
     var e_210, _a;
     var entries = {};
     var counter = 1;
@@ -50476,7 +51255,7 @@ var serializeAws_ec2VpcEndpointIdList = function (input, context) {
             if (entry === null) {
                 continue;
             }
-            entries["Item.".concat(counter)] = entry;
+            entries["VolumeId.".concat(counter)] = entry;
             counter++;
         }
     }
@@ -50489,7 +51268,7 @@ var serializeAws_ec2VpcEndpointIdList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpcEndpointRouteTableIdList = function (input, context) {
+var serializeAws_ec2VpcClassicLinkIdList = function (input, context) {
     var e_211, _a;
     var entries = {};
     var counter = 1;
@@ -50499,7 +51278,7 @@ var serializeAws_ec2VpcEndpointRouteTableIdList = function (input, context) {
             if (entry === null) {
                 continue;
             }
-            entries["Item.".concat(counter)] = entry;
+            entries["VpcId.".concat(counter)] = entry;
             counter++;
         }
     }
@@ -50512,7 +51291,7 @@ var serializeAws_ec2VpcEndpointRouteTableIdList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpcEndpointSecurityGroupIdList = function (input, context) {
+var serializeAws_ec2VpcEndpointIdList = function (input, context) {
     var e_212, _a;
     var entries = {};
     var counter = 1;
@@ -50535,7 +51314,7 @@ var serializeAws_ec2VpcEndpointSecurityGroupIdList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpcEndpointServiceIdList = function (input, context) {
+var serializeAws_ec2VpcEndpointRouteTableIdList = function (input, context) {
     var e_213, _a;
     var entries = {};
     var counter = 1;
@@ -50558,7 +51337,7 @@ var serializeAws_ec2VpcEndpointServiceIdList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpcEndpointSubnetIdList = function (input, context) {
+var serializeAws_ec2VpcEndpointSecurityGroupIdList = function (input, context) {
     var e_214, _a;
     var entries = {};
     var counter = 1;
@@ -50581,7 +51360,7 @@ var serializeAws_ec2VpcEndpointSubnetIdList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpcIdStringList = function (input, context) {
+var serializeAws_ec2VpcEndpointServiceIdList = function (input, context) {
     var e_215, _a;
     var entries = {};
     var counter = 1;
@@ -50591,7 +51370,7 @@ var serializeAws_ec2VpcIdStringList = function (input, context) {
             if (entry === null) {
                 continue;
             }
-            entries["VpcId.".concat(counter)] = entry;
+            entries["Item.".concat(counter)] = entry;
             counter++;
         }
     }
@@ -50604,7 +51383,7 @@ var serializeAws_ec2VpcIdStringList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpcPeeringConnectionIdList = function (input, context) {
+var serializeAws_ec2VpcEndpointSubnetIdList = function (input, context) {
     var e_216, _a;
     var entries = {};
     var counter = 1;
@@ -50627,7 +51406,7 @@ var serializeAws_ec2VpcPeeringConnectionIdList = function (input, context) {
     }
     return entries;
 };
-var serializeAws_ec2VpnConnectionIdStringList = function (input, context) {
+var serializeAws_ec2VpcIdStringList = function (input, context) {
     var e_217, _a;
     var entries = {};
     var counter = 1;
@@ -50637,7 +51416,7 @@ var serializeAws_ec2VpnConnectionIdStringList = function (input, context) {
             if (entry === null) {
                 continue;
             }
-            entries["VpnConnectionId.".concat(counter)] = entry;
+            entries["VpcId.".concat(counter)] = entry;
             counter++;
         }
     }
@@ -50650,6 +51429,52 @@ var serializeAws_ec2VpnConnectionIdStringList = function (input, context) {
     }
     return entries;
 };
+var serializeAws_ec2VpcPeeringConnectionIdList = function (input, context) {
+    var e_218, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_218 = __values(input), input_218_1 = input_218.next(); !input_218_1.done; input_218_1 = input_218.next()) {
+            var entry = input_218_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["Item.".concat(counter)] = entry;
+            counter++;
+        }
+    }
+    catch (e_218_1) { e_218 = { error: e_218_1 }; }
+    finally {
+        try {
+            if (input_218_1 && !input_218_1.done && (_a = input_218.return)) _a.call(input_218);
+        }
+        finally { if (e_218) throw e_218.error; }
+    }
+    return entries;
+};
+var serializeAws_ec2VpnConnectionIdStringList = function (input, context) {
+    var e_219, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_219 = __values(input), input_219_1 = input_219.next(); !input_219_1.done; input_219_1 = input_219.next()) {
+            var entry = input_219_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["VpnConnectionId.".concat(counter)] = entry;
+            counter++;
+        }
+    }
+    catch (e_219_1) { e_219 = { error: e_219_1 }; }
+    finally {
+        try {
+            if (input_219_1 && !input_219_1.done && (_a = input_219.return)) _a.call(input_219);
+        }
+        finally { if (e_219) throw e_219.error; }
+    }
+    return entries;
+};
 var serializeAws_ec2VpnConnectionOptionsSpecification = function (input, context) {
     var entries = {};
     if (input.EnableAcceleration !== undefined && input.EnableAcceleration !== null) {
@@ -50690,12 +51515,12 @@ var serializeAws_ec2VpnConnectionOptionsSpecification = function (input, context
     return entries;
 };
 var serializeAws_ec2VpnGatewayIdStringList = function (input, context) {
-    var e_218, _a;
+    var e_220, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_218 = __values(input), input_218_1 = input_218.next(); !input_218_1.done; input_218_1 = input_218.next()) {
-            var entry = input_218_1.value;
+        for (var input_220 = __values(input), input_220_1 = input_220.next(); !input_220_1.done; input_220_1 = input_220.next()) {
+            var entry = input_220_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50703,12 +51528,12 @@ var serializeAws_ec2VpnGatewayIdStringList = function (input, context) {
             counter++;
         }
     }
-    catch (e_218_1) { e_218 = { error: e_218_1 }; }
+    catch (e_220_1) { e_220 = { error: e_220_1 }; }
     finally {
         try {
-            if (input_218_1 && !input_218_1.done && (_a = input_218.return)) _a.call(input_218);
+            if (input_220_1 && !input_220_1.done && (_a = input_220.return)) _a.call(input_220);
         }
-        finally { if (e_218) throw e_218.error; }
+        finally { if (e_220) throw e_220.error; }
     }
     return entries;
 };
@@ -50806,12 +51631,12 @@ var serializeAws_ec2VpnTunnelOptionsSpecification = function (input, context) {
     return entries;
 };
 var serializeAws_ec2VpnTunnelOptionsSpecificationsList = function (input, context) {
-    var e_219, _a;
+    var e_221, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_219 = __values(input), input_219_1 = input_219.next(); !input_219_1.done; input_219_1 = input_219.next()) {
-            var entry = input_219_1.value;
+        for (var input_221 = __values(input), input_221_1 = input_221.next(); !input_221_1.done; input_221_1 = input_221.next()) {
+            var entry = input_221_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50823,12 +51648,12 @@ var serializeAws_ec2VpnTunnelOptionsSpecificationsList = function (input, contex
             counter++;
         }
     }
-    catch (e_219_1) { e_219 = { error: e_219_1 }; }
+    catch (e_221_1) { e_221 = { error: e_221_1 }; }
     finally {
         try {
-            if (input_219_1 && !input_219_1.done && (_a = input_219.return)) _a.call(input_219);
+            if (input_221_1 && !input_221_1.done && (_a = input_221.return)) _a.call(input_221);
         }
-        finally { if (e_219) throw e_219.error; }
+        finally { if (e_221) throw e_221.error; }
     }
     return entries;
 };
@@ -50843,12 +51668,12 @@ var serializeAws_ec2WithdrawByoipCidrRequest = function (input, context) {
     return entries;
 };
 var serializeAws_ec2ZoneIdStringList = function (input, context) {
-    var e_220, _a;
+    var e_222, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_220 = __values(input), input_220_1 = input_220.next(); !input_220_1.done; input_220_1 = input_220.next()) {
-            var entry = input_220_1.value;
+        for (var input_222 = __values(input), input_222_1 = input_222.next(); !input_222_1.done; input_222_1 = input_222.next()) {
+            var entry = input_222_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50856,22 +51681,22 @@ var serializeAws_ec2ZoneIdStringList = function (input, context) {
             counter++;
         }
     }
-    catch (e_220_1) { e_220 = { error: e_220_1 }; }
+    catch (e_222_1) { e_222 = { error: e_222_1 }; }
     finally {
         try {
-            if (input_220_1 && !input_220_1.done && (_a = input_220.return)) _a.call(input_220);
+            if (input_222_1 && !input_222_1.done && (_a = input_222.return)) _a.call(input_222);
         }
-        finally { if (e_220) throw e_220.error; }
+        finally { if (e_222) throw e_222.error; }
     }
     return entries;
 };
 var serializeAws_ec2ZoneNameStringList = function (input, context) {
-    var e_221, _a;
+    var e_223, _a;
     var entries = {};
     var counter = 1;
     try {
-        for (var input_221 = __values(input), input_221_1 = input_221.next(); !input_221_1.done; input_221_1 = input_221.next()) {
-            var entry = input_221_1.value;
+        for (var input_223 = __values(input), input_223_1 = input_223.next(); !input_223_1.done; input_223_1 = input_223.next()) {
+            var entry = input_223_1.value;
             if (entry === null) {
                 continue;
             }
@@ -50879,12 +51704,12 @@ var serializeAws_ec2ZoneNameStringList = function (input, context) {
             counter++;
         }
     }
-    catch (e_221_1) { e_221 = { error: e_221_1 }; }
+    catch (e_223_1) { e_223 = { error: e_223_1 }; }
     finally {
         try {
-            if (input_221_1 && !input_221_1.done && (_a = input_221.return)) _a.call(input_221);
+            if (input_223_1 && !input_223_1.done && (_a = input_223.return)) _a.call(input_223);
         }
-        finally { if (e_221) throw e_221.error; }
+        finally { if (e_223) throw e_223.error; }
     }
     return entries;
 };
@@ -51828,6 +52653,15 @@ var deserializeAws_ec2AssociateTransitGatewayMulticastDomainResult = function (o
     }
     return contents;
 };
+var deserializeAws_ec2AssociateTransitGatewayPolicyTableResult = function (output, context) {
+    var contents = {
+        Association: undefined,
+    };
+    if (output["association"] !== undefined) {
+        contents.Association = deserializeAws_ec2TransitGatewayPolicyTableAssociation(output["association"], context);
+    }
+    return contents;
+};
 var deserializeAws_ec2AssociateTransitGatewayRouteTableResult = function (output, context) {
     var contents = {
         Association: undefined,
@@ -54199,6 +55033,15 @@ var deserializeAws_ec2CreateTransitGatewayPeeringAttachmentResult = function (ou
     }
     return contents;
 };
+var deserializeAws_ec2CreateTransitGatewayPolicyTableResult = function (output, context) {
+    var contents = {
+        TransitGatewayPolicyTable: undefined,
+    };
+    if (output["transitGatewayPolicyTable"] !== undefined) {
+        contents.TransitGatewayPolicyTable = deserializeAws_ec2TransitGatewayPolicyTable(output["transitGatewayPolicyTable"], context);
+    }
+    return contents;
+};
 var deserializeAws_ec2CreateTransitGatewayPrefixListReferenceResult = function (output, context) {
     var contents = {
         TransitGatewayPrefixListReference: undefined,
@@ -54226,6 +55069,15 @@ var deserializeAws_ec2CreateTransitGatewayRouteResult = function (output, contex
     }
     return contents;
 };
+var deserializeAws_ec2CreateTransitGatewayRouteTableAnnouncementResult = function (output, context) {
+    var contents = {
+        TransitGatewayRouteTableAnnouncement: undefined,
+    };
+    if (output["transitGatewayRouteTableAnnouncement"] !== undefined) {
+        contents.TransitGatewayRouteTableAnnouncement = deserializeAws_ec2TransitGatewayRouteTableAnnouncement(output["transitGatewayRouteTableAnnouncement"], context);
+    }
+    return contents;
+};
 var deserializeAws_ec2CreateTransitGatewayRouteTableResult = function (output, context) {
     var contents = {
         TransitGatewayRouteTable: undefined,
@@ -54883,6 +55735,15 @@ var deserializeAws_ec2DeleteTransitGatewayPeeringAttachmentResult = function (ou
     }
     return contents;
 };
+var deserializeAws_ec2DeleteTransitGatewayPolicyTableResult = function (output, context) {
+    var contents = {
+        TransitGatewayPolicyTable: undefined,
+    };
+    if (output["transitGatewayPolicyTable"] !== undefined) {
+        contents.TransitGatewayPolicyTable = deserializeAws_ec2TransitGatewayPolicyTable(output["transitGatewayPolicyTable"], context);
+    }
+    return contents;
+};
 var deserializeAws_ec2DeleteTransitGatewayPrefixListReferenceResult = function (output, context) {
     var contents = {
         TransitGatewayPrefixListReference: undefined,
@@ -54910,6 +55771,15 @@ var deserializeAws_ec2DeleteTransitGatewayRouteResult = function (output, contex
     }
     return contents;
 };
+var deserializeAws_ec2DeleteTransitGatewayRouteTableAnnouncementResult = function (output, context) {
+    var contents = {
+        TransitGatewayRouteTableAnnouncement: undefined,
+    };
+    if (output["transitGatewayRouteTableAnnouncement"] !== undefined) {
+        contents.TransitGatewayRouteTableAnnouncement = deserializeAws_ec2TransitGatewayRouteTableAnnouncement(output["transitGatewayRouteTableAnnouncement"], context);
+    }
+    return contents;
+};
 var deserializeAws_ec2DeleteTransitGatewayRouteTableResult = function (output, context) {
     var contents = {
         TransitGatewayRouteTable: undefined,
@@ -56995,6 +57865,40 @@ var deserializeAws_ec2DescribeTransitGatewayPeeringAttachmentsResult = function
     }
     return contents;
 };
+var deserializeAws_ec2DescribeTransitGatewayPolicyTablesResult = function (output, context) {
+    var contents = {
+        TransitGatewayPolicyTables: undefined,
+        NextToken: undefined,
+    };
+    if (output.transitGatewayPolicyTables === "") {
+        contents.TransitGatewayPolicyTables = [];
+    }
+    else if (output["transitGatewayPolicyTables"] !== undefined &&
+        output["transitGatewayPolicyTables"]["item"] !== undefined) {
+        contents.TransitGatewayPolicyTables = deserializeAws_ec2TransitGatewayPolicyTableList(__getArrayIfSingleItem(output["transitGatewayPolicyTables"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
+var deserializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsResult = function (output, context) {
+    var contents = {
+        TransitGatewayRouteTableAnnouncements: undefined,
+        NextToken: undefined,
+    };
+    if (output.transitGatewayRouteTableAnnouncements === "") {
+        contents.TransitGatewayRouteTableAnnouncements = [];
+    }
+    else if (output["transitGatewayRouteTableAnnouncements"] !== undefined &&
+        output["transitGatewayRouteTableAnnouncements"]["item"] !== undefined) {
+        contents.TransitGatewayRouteTableAnnouncements = deserializeAws_ec2TransitGatewayRouteTableAnnouncementList(__getArrayIfSingleItem(output["transitGatewayRouteTableAnnouncements"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
 var deserializeAws_ec2DescribeTransitGatewayRouteTablesResult = function (output, context) {
     var contents = {
         TransitGatewayRouteTables: undefined,
@@ -57753,6 +58657,15 @@ var deserializeAws_ec2DisassociateTransitGatewayMulticastDomainResult = function
     }
     return contents;
 };
+var deserializeAws_ec2DisassociateTransitGatewayPolicyTableResult = function (output, context) {
+    var contents = {
+        Association: undefined,
+    };
+    if (output["association"] !== undefined) {
+        contents.Association = deserializeAws_ec2TransitGatewayPolicyTableAssociation(output["association"], context);
+    }
+    return contents;
+};
 var deserializeAws_ec2DisassociateTransitGatewayRouteTableResult = function (output, context) {
     var contents = {
         Association: undefined,
@@ -60053,6 +60966,35 @@ var deserializeAws_ec2GetTransitGatewayMulticastDomainAssociationsResult = funct
     }
     return contents;
 };
+var deserializeAws_ec2GetTransitGatewayPolicyTableAssociationsResult = function (output, context) {
+    var contents = {
+        Associations: undefined,
+        NextToken: undefined,
+    };
+    if (output.associations === "") {
+        contents.Associations = [];
+    }
+    else if (output["associations"] !== undefined && output["associations"]["item"] !== undefined) {
+        contents.Associations = deserializeAws_ec2TransitGatewayPolicyTableAssociationList(__getArrayIfSingleItem(output["associations"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
+var deserializeAws_ec2GetTransitGatewayPolicyTableEntriesResult = function (output, context) {
+    var contents = {
+        TransitGatewayPolicyTableEntries: undefined,
+    };
+    if (output.transitGatewayPolicyTableEntries === "") {
+        contents.TransitGatewayPolicyTableEntries = [];
+    }
+    else if (output["transitGatewayPolicyTableEntries"] !== undefined &&
+        output["transitGatewayPolicyTableEntries"]["item"] !== undefined) {
+        contents.TransitGatewayPolicyTableEntries = deserializeAws_ec2TransitGatewayPolicyTableEntryList(__getArrayIfSingleItem(output["transitGatewayPolicyTableEntries"]["item"]), context);
+    }
+    return contents;
+};
 var deserializeAws_ec2GetTransitGatewayPrefixListReferencesResult = function (output, context) {
     var contents = {
         TransitGatewayPrefixListReferences: undefined,
@@ -66795,12 +67737,16 @@ var deserializeAws_ec2PeeringConnectionOptions = function (output, context) {
 var deserializeAws_ec2PeeringTgwInfo = function (output, context) {
     var contents = {
         TransitGatewayId: undefined,
+        CoreNetworkId: undefined,
         OwnerId: undefined,
         Region: undefined,
     };
     if (output["transitGatewayId"] !== undefined) {
         contents.TransitGatewayId = __expectString(output["transitGatewayId"]);
     }
+    if (output["coreNetworkId"] !== undefined) {
+        contents.CoreNetworkId = __expectString(output["coreNetworkId"]);
+    }
     if (output["ownerId"] !== undefined) {
         contents.OwnerId = __expectString(output["ownerId"]);
     }
@@ -72281,8 +73227,10 @@ var deserializeAws_ec2TransitGatewayOptions = function (output, context) {
 var deserializeAws_ec2TransitGatewayPeeringAttachment = function (output, context) {
     var contents = {
         TransitGatewayAttachmentId: undefined,
+        AccepterTransitGatewayAttachmentId: undefined,
         RequesterTgwInfo: undefined,
         AccepterTgwInfo: undefined,
+        Options: undefined,
         Status: undefined,
         State: undefined,
         CreationTime: undefined,
@@ -72291,12 +73239,18 @@ var deserializeAws_ec2TransitGatewayPeeringAttachment = function (output, contex
     if (output["transitGatewayAttachmentId"] !== undefined) {
         contents.TransitGatewayAttachmentId = __expectString(output["transitGatewayAttachmentId"]);
     }
+    if (output["accepterTransitGatewayAttachmentId"] !== undefined) {
+        contents.AccepterTransitGatewayAttachmentId = __expectString(output["accepterTransitGatewayAttachmentId"]);
+    }
     if (output["requesterTgwInfo"] !== undefined) {
         contents.RequesterTgwInfo = deserializeAws_ec2PeeringTgwInfo(output["requesterTgwInfo"], context);
     }
     if (output["accepterTgwInfo"] !== undefined) {
         contents.AccepterTgwInfo = deserializeAws_ec2PeeringTgwInfo(output["accepterTgwInfo"], context);
     }
+    if (output["options"] !== undefined) {
+        contents.Options = deserializeAws_ec2TransitGatewayPeeringAttachmentOptions(output["options"], context);
+    }
     if (output["status"] !== undefined) {
         contents.Status = deserializeAws_ec2PeeringAttachmentStatus(output["status"], context);
     }
@@ -72324,6 +73278,157 @@ var deserializeAws_ec2TransitGatewayPeeringAttachmentList = function (output, co
         return deserializeAws_ec2TransitGatewayPeeringAttachment(entry, context);
     });
 };
+var deserializeAws_ec2TransitGatewayPeeringAttachmentOptions = function (output, context) {
+    var contents = {
+        DynamicRouting: undefined,
+    };
+    if (output["dynamicRouting"] !== undefined) {
+        contents.DynamicRouting = __expectString(output["dynamicRouting"]);
+    }
+    return contents;
+};
+var deserializeAws_ec2TransitGatewayPolicyRule = function (output, context) {
+    var contents = {
+        SourceCidrBlock: undefined,
+        SourcePortRange: undefined,
+        DestinationCidrBlock: undefined,
+        DestinationPortRange: undefined,
+        Protocol: undefined,
+        MetaData: undefined,
+    };
+    if (output["sourceCidrBlock"] !== undefined) {
+        contents.SourceCidrBlock = __expectString(output["sourceCidrBlock"]);
+    }
+    if (output["sourcePortRange"] !== undefined) {
+        contents.SourcePortRange = __expectString(output["sourcePortRange"]);
+    }
+    if (output["destinationCidrBlock"] !== undefined) {
+        contents.DestinationCidrBlock = __expectString(output["destinationCidrBlock"]);
+    }
+    if (output["destinationPortRange"] !== undefined) {
+        contents.DestinationPortRange = __expectString(output["destinationPortRange"]);
+    }
+    if (output["protocol"] !== undefined) {
+        contents.Protocol = __expectString(output["protocol"]);
+    }
+    if (output["metaData"] !== undefined) {
+        contents.MetaData = deserializeAws_ec2TransitGatewayPolicyRuleMetaData(output["metaData"], context);
+    }
+    return contents;
+};
+var deserializeAws_ec2TransitGatewayPolicyRuleMetaData = function (output, context) {
+    var contents = {
+        MetaDataKey: undefined,
+        MetaDataValue: undefined,
+    };
+    if (output["metaDataKey"] !== undefined) {
+        contents.MetaDataKey = __expectString(output["metaDataKey"]);
+    }
+    if (output["metaDataValue"] !== undefined) {
+        contents.MetaDataValue = __expectString(output["metaDataValue"]);
+    }
+    return contents;
+};
+var deserializeAws_ec2TransitGatewayPolicyTable = function (output, context) {
+    var contents = {
+        TransitGatewayPolicyTableId: undefined,
+        TransitGatewayId: undefined,
+        State: undefined,
+        CreationTime: undefined,
+        Tags: undefined,
+    };
+    if (output["transitGatewayPolicyTableId"] !== undefined) {
+        contents.TransitGatewayPolicyTableId = __expectString(output["transitGatewayPolicyTableId"]);
+    }
+    if (output["transitGatewayId"] !== undefined) {
+        contents.TransitGatewayId = __expectString(output["transitGatewayId"]);
+    }
+    if (output["state"] !== undefined) {
+        contents.State = __expectString(output["state"]);
+    }
+    if (output["creationTime"] !== undefined) {
+        contents.CreationTime = __expectNonNull(__parseRfc3339DateTime(output["creationTime"]));
+    }
+    if (output.tagSet === "") {
+        contents.Tags = [];
+    }
+    else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
+        contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
+    }
+    return contents;
+};
+var deserializeAws_ec2TransitGatewayPolicyTableAssociation = function (output, context) {
+    var contents = {
+        TransitGatewayPolicyTableId: undefined,
+        TransitGatewayAttachmentId: undefined,
+        ResourceId: undefined,
+        ResourceType: undefined,
+        State: undefined,
+    };
+    if (output["transitGatewayPolicyTableId"] !== undefined) {
+        contents.TransitGatewayPolicyTableId = __expectString(output["transitGatewayPolicyTableId"]);
+    }
+    if (output["transitGatewayAttachmentId"] !== undefined) {
+        contents.TransitGatewayAttachmentId = __expectString(output["transitGatewayAttachmentId"]);
+    }
+    if (output["resourceId"] !== undefined) {
+        contents.ResourceId = __expectString(output["resourceId"]);
+    }
+    if (output["resourceType"] !== undefined) {
+        contents.ResourceType = __expectString(output["resourceType"]);
+    }
+    if (output["state"] !== undefined) {
+        contents.State = __expectString(output["state"]);
+    }
+    return contents;
+};
+var deserializeAws_ec2TransitGatewayPolicyTableAssociationList = function (output, context) {
+    return (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_ec2TransitGatewayPolicyTableAssociation(entry, context);
+    });
+};
+var deserializeAws_ec2TransitGatewayPolicyTableEntry = function (output, context) {
+    var contents = {
+        PolicyRuleNumber: undefined,
+        PolicyRule: undefined,
+        TargetRouteTableId: undefined,
+    };
+    if (output["policyRuleNumber"] !== undefined) {
+        contents.PolicyRuleNumber = __expectString(output["policyRuleNumber"]);
+    }
+    if (output["policyRule"] !== undefined) {
+        contents.PolicyRule = deserializeAws_ec2TransitGatewayPolicyRule(output["policyRule"], context);
+    }
+    if (output["targetRouteTableId"] !== undefined) {
+        contents.TargetRouteTableId = __expectString(output["targetRouteTableId"]);
+    }
+    return contents;
+};
+var deserializeAws_ec2TransitGatewayPolicyTableEntryList = function (output, context) {
+    return (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_ec2TransitGatewayPolicyTableEntry(entry, context);
+    });
+};
+var deserializeAws_ec2TransitGatewayPolicyTableList = function (output, context) {
+    return (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_ec2TransitGatewayPolicyTable(entry, context);
+    });
+};
 var deserializeAws_ec2TransitGatewayPrefixListAttachment = function (output, context) {
     var contents = {
         TransitGatewayAttachmentId: undefined,
@@ -72387,6 +73492,7 @@ var deserializeAws_ec2TransitGatewayPropagation = function (output, context) {
         ResourceType: undefined,
         TransitGatewayRouteTableId: undefined,
         State: undefined,
+        TransitGatewayRouteTableAnnouncementId: undefined,
     };
     if (output["transitGatewayAttachmentId"] !== undefined) {
         contents.TransitGatewayAttachmentId = __expectString(output["transitGatewayAttachmentId"]);
@@ -72403,12 +73509,16 @@ var deserializeAws_ec2TransitGatewayPropagation = function (output, context) {
     if (output["state"] !== undefined) {
         contents.State = __expectString(output["state"]);
     }
+    if (output["transitGatewayRouteTableAnnouncementId"] !== undefined) {
+        contents.TransitGatewayRouteTableAnnouncementId = __expectString(output["transitGatewayRouteTableAnnouncementId"]);
+    }
     return contents;
 };
 var deserializeAws_ec2TransitGatewayRoute = function (output, context) {
     var contents = {
         DestinationCidrBlock: undefined,
         PrefixListId: undefined,
+        TransitGatewayRouteTableAnnouncementId: undefined,
         TransitGatewayAttachments: undefined,
         Type: undefined,
         State: undefined,
@@ -72419,6 +73529,9 @@ var deserializeAws_ec2TransitGatewayRoute = function (output, context) {
     if (output["prefixListId"] !== undefined) {
         contents.PrefixListId = __expectString(output["prefixListId"]);
     }
+    if (output["transitGatewayRouteTableAnnouncementId"] !== undefined) {
+        contents.TransitGatewayRouteTableAnnouncementId = __expectString(output["transitGatewayRouteTableAnnouncementId"]);
+    }
     if (output.transitGatewayAttachments === "") {
         contents.TransitGatewayAttachments = [];
     }
@@ -72507,6 +73620,68 @@ var deserializeAws_ec2TransitGatewayRouteTable = function (output, context) {
     }
     return contents;
 };
+var deserializeAws_ec2TransitGatewayRouteTableAnnouncement = function (output, context) {
+    var contents = {
+        TransitGatewayRouteTableAnnouncementId: undefined,
+        TransitGatewayId: undefined,
+        CoreNetworkId: undefined,
+        PeerTransitGatewayId: undefined,
+        PeerCoreNetworkId: undefined,
+        PeeringAttachmentId: undefined,
+        AnnouncementDirection: undefined,
+        TransitGatewayRouteTableId: undefined,
+        State: undefined,
+        CreationTime: undefined,
+        Tags: undefined,
+    };
+    if (output["transitGatewayRouteTableAnnouncementId"] !== undefined) {
+        contents.TransitGatewayRouteTableAnnouncementId = __expectString(output["transitGatewayRouteTableAnnouncementId"]);
+    }
+    if (output["transitGatewayId"] !== undefined) {
+        contents.TransitGatewayId = __expectString(output["transitGatewayId"]);
+    }
+    if (output["coreNetworkId"] !== undefined) {
+        contents.CoreNetworkId = __expectString(output["coreNetworkId"]);
+    }
+    if (output["peerTransitGatewayId"] !== undefined) {
+        contents.PeerTransitGatewayId = __expectString(output["peerTransitGatewayId"]);
+    }
+    if (output["peerCoreNetworkId"] !== undefined) {
+        contents.PeerCoreNetworkId = __expectString(output["peerCoreNetworkId"]);
+    }
+    if (output["peeringAttachmentId"] !== undefined) {
+        contents.PeeringAttachmentId = __expectString(output["peeringAttachmentId"]);
+    }
+    if (output["announcementDirection"] !== undefined) {
+        contents.AnnouncementDirection = __expectString(output["announcementDirection"]);
+    }
+    if (output["transitGatewayRouteTableId"] !== undefined) {
+        contents.TransitGatewayRouteTableId = __expectString(output["transitGatewayRouteTableId"]);
+    }
+    if (output["state"] !== undefined) {
+        contents.State = __expectString(output["state"]);
+    }
+    if (output["creationTime"] !== undefined) {
+        contents.CreationTime = __expectNonNull(__parseRfc3339DateTime(output["creationTime"]));
+    }
+    if (output.tagSet === "") {
+        contents.Tags = [];
+    }
+    else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
+        contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
+    }
+    return contents;
+};
+var deserializeAws_ec2TransitGatewayRouteTableAnnouncementList = function (output, context) {
+    return (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_ec2TransitGatewayRouteTableAnnouncement(entry, context);
+    });
+};
 var deserializeAws_ec2TransitGatewayRouteTableAssociation = function (output, context) {
     var contents = {
         TransitGatewayAttachmentId: undefined,
@@ -72554,6 +73729,7 @@ var deserializeAws_ec2TransitGatewayRouteTablePropagation = function (output, co
         ResourceId: undefined,
         ResourceType: undefined,
         State: undefined,
+        TransitGatewayRouteTableAnnouncementId: undefined,
     };
     if (output["transitGatewayAttachmentId"] !== undefined) {
         contents.TransitGatewayAttachmentId = __expectString(output["transitGatewayAttachmentId"]);
@@ -72567,6 +73743,9 @@ var deserializeAws_ec2TransitGatewayRouteTablePropagation = function (output, co
     if (output["state"] !== undefined) {
         contents.State = __expectString(output["state"]);
     }
+    if (output["transitGatewayRouteTableAnnouncementId"] !== undefined) {
+        contents.TransitGatewayRouteTableAnnouncementId = __expectString(output["transitGatewayRouteTableAnnouncementId"]);
+    }
     return contents;
 };
 var deserializeAws_ec2TransitGatewayRouteTablePropagationList = function (output, context) {