@aws-sdk/client-mediaconnect 3.312.0 → 3.315.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,7 +1,49 @@
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
-import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map as __map, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
+import { _json, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@aws-sdk/smithy-client";
 import { MediaConnectServiceException as __BaseException } from "../models/MediaConnectServiceException";
-import { AddFlowOutputs420Exception, BadRequestException, CreateFlow420Exception, ForbiddenException, GrantFlowEntitlements420Exception, InternalServerErrorException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, } from "../models/models_0";
+import { AddFlowOutputs420Exception, BadRequestException, ConflictException, CreateBridge420Exception, CreateFlow420Exception, CreateGateway420Exception, ForbiddenException, GrantFlowEntitlements420Exception, InternalServerErrorException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, } from "../models/models_0";
+export const se_AddBridgeOutputsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/outputs";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        outputs: [, (_) => se___listOfAddBridgeOutputRequest(_, context), `Outputs`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_AddBridgeSourcesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/sources";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        sources: [, (_) => se___listOfAddBridgeSourceRequest(_, context), `Sources`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_AddFlowMediaStreamsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -10,9 +52,9 @@ export const se_AddFlowMediaStreamsCommand = async (input, context) => {
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/mediaStreams";
     resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.MediaStreams != null && { mediaStreams: se___listOfAddMediaStreamRequest(input.MediaStreams, context) }),
-    });
+    body = JSON.stringify(take(input, {
+        mediaStreams: [, (_) => se___listOfAddMediaStreamRequest(_, context), `MediaStreams`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -31,9 +73,9 @@ export const se_AddFlowOutputsCommand = async (input, context) => {
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/outputs";
     resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.Outputs != null && { outputs: se___listOfAddOutputRequest(input.Outputs, context) }),
-    });
+    body = JSON.stringify(take(input, {
+        outputs: [, (_) => se___listOfAddOutputRequest(_, context), `Outputs`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -52,9 +94,9 @@ export const se_AddFlowSourcesCommand = async (input, context) => {
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/source";
     resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.Sources != null && { sources: se___listOfSetSourceRequest(input.Sources, context) }),
-    });
+    body = JSON.stringify(take(input, {
+        sources: [, (_) => se___listOfSetSourceRequest(_, context), `Sources`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -73,9 +115,35 @@ export const se_AddFlowVpcInterfacesCommand = async (input, context) => {
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/vpcInterfaces";
     resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.VpcInterfaces != null && { vpcInterfaces: se___listOfVpcInterfaceRequest(input.VpcInterfaces, context) }),
+    body = JSON.stringify(take(input, {
+        vpcInterfaces: [, (_) => se___listOfVpcInterfaceRequest(_, context), `VpcInterfaces`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
     });
+};
+export const se_CreateBridgeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges";
+    let body;
+    body = JSON.stringify(take(input, {
+        egressGatewayBridge: [, (_) => se_AddEgressGatewayBridgeRequest(_, context), `EgressGatewayBridge`],
+        ingressGatewayBridge: [, (_) => se_AddIngressGatewayBridgeRequest(_, context), `IngressGatewayBridge`],
+        name: [, , `Name`],
+        outputs: [, (_) => se___listOfAddBridgeOutputRequest(_, context), `Outputs`],
+        placementArn: [, , `PlacementArn`],
+        sourceFailoverConfig: [, (_) => se_FailoverConfig(_, context), `SourceFailoverConfig`],
+        sources: [, (_) => se___listOfAddBridgeSourceRequest(_, context), `Sources`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -93,22 +161,40 @@ export const se_CreateFlowCommand = async (input, context) => {
     };
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows";
     let body;
-    body = JSON.stringify({
-        ...(input.AvailabilityZone != null && { availabilityZone: input.AvailabilityZone }),
-        ...(input.Entitlements != null && {
-            entitlements: se___listOfGrantEntitlementRequest(input.Entitlements, context),
-        }),
-        ...(input.Maintenance != null && { maintenance: se_AddMaintenance(input.Maintenance, context) }),
-        ...(input.MediaStreams != null && { mediaStreams: se___listOfAddMediaStreamRequest(input.MediaStreams, context) }),
-        ...(input.Name != null && { name: input.Name }),
-        ...(input.Outputs != null && { outputs: se___listOfAddOutputRequest(input.Outputs, context) }),
-        ...(input.Source != null && { source: se_SetSourceRequest(input.Source, context) }),
-        ...(input.SourceFailoverConfig != null && {
-            sourceFailoverConfig: se_FailoverConfig(input.SourceFailoverConfig, context),
-        }),
-        ...(input.Sources != null && { sources: se___listOfSetSourceRequest(input.Sources, context) }),
-        ...(input.VpcInterfaces != null && { vpcInterfaces: se___listOfVpcInterfaceRequest(input.VpcInterfaces, context) }),
+    body = JSON.stringify(take(input, {
+        availabilityZone: [, , `AvailabilityZone`],
+        entitlements: [, (_) => se___listOfGrantEntitlementRequest(_, context), `Entitlements`],
+        maintenance: [, (_) => se_AddMaintenance(_, context), `Maintenance`],
+        mediaStreams: [, (_) => se___listOfAddMediaStreamRequest(_, context), `MediaStreams`],
+        name: [, , `Name`],
+        outputs: [, (_) => se___listOfAddOutputRequest(_, context), `Outputs`],
+        source: [, (_) => se_SetSourceRequest(_, context), `Source`],
+        sourceFailoverConfig: [, (_) => se_FailoverConfig(_, context), `SourceFailoverConfig`],
+        sources: [, (_) => se___listOfSetSourceRequest(_, context), `Sources`],
+        vpcInterfaces: [, (_) => se___listOfVpcInterfaceRequest(_, context), `VpcInterfaces`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
     });
+};
+export const se_CreateGatewayCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways";
+    let body;
+    body = JSON.stringify(take(input, {
+        egressCidrBlocks: [, (_) => _json(_), `EgressCidrBlocks`],
+        name: [, , `Name`],
+        networks: [, (_) => se___listOfGatewayNetwork(_, context), `Networks`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -119,6 +205,22 @@ export const se_CreateFlowCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteBridgeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DeleteFlowCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -135,6 +237,59 @@ export const se_DeleteFlowCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteGatewayCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways/{GatewayArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayArn", () => input.GatewayArn, "{GatewayArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_DeregisterGatewayInstanceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/gateway-instances/{GatewayInstanceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
+    const query = map({
+        force: [() => input.Force !== void 0, () => input.Force.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_DescribeBridgeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DescribeFlowCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -151,6 +306,39 @@ export const se_DescribeFlowCommand = async (input, context) => {
         body,
     });
 };
+export const se_DescribeGatewayCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways/{GatewayArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayArn", () => input.GatewayArn, "{GatewayArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_DescribeGatewayInstanceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/gateway-instances/{GatewayInstanceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DescribeOfferingCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -191,11 +379,9 @@ export const se_GrantFlowEntitlementsCommand = async (input, context) => {
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/entitlements";
     resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.Entitlements != null && {
-            entitlements: se___listOfGrantEntitlementRequest(input.Entitlements, context),
-        }),
-    });
+    body = JSON.stringify(take(input, {
+        entitlements: [, (_) => se___listOfGrantEntitlementRequest(_, context), `Entitlements`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -206,6 +392,27 @@ export const se_GrantFlowEntitlementsCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListBridgesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges";
+    const query = map({
+        filterArn: [, input.FilterArn],
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        nextToken: [, input.NextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListEntitlementsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -246,6 +453,47 @@ export const se_ListFlowsCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListGatewayInstancesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateway-instances";
+    const query = map({
+        filterArn: [, input.FilterArn],
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        nextToken: [, input.NextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ListGatewaysCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways";
+    const query = map({
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        nextToken: [, input.NextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListOfferingsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -310,10 +558,10 @@ export const se_PurchaseOfferingCommand = async (input, context) => {
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/offerings/{OfferingArn}";
     resolvedPath = __resolvedPath(resolvedPath, input, "OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.ReservationName != null && { reservationName: input.ReservationName }),
-        ...(input.Start != null && { start: input.Start }),
-    });
+    body = JSON.stringify(take(input, {
+        reservationName: [, , `ReservationName`],
+        start: [, , `Start`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -324,6 +572,42 @@ export const se_PurchaseOfferingCommand = async (input, context) => {
         body,
     });
 };
+export const se_RemoveBridgeOutputCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/bridges/{BridgeArn}/outputs/{OutputName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "OutputName", () => input.OutputName, "{OutputName}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_RemoveBridgeSourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/bridges/{BridgeArn}/sources/{SourceName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "SourceName", () => input.SourceName, "{SourceName}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_RemoveFlowMediaStreamCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -452,9 +736,9 @@ export const se_TagResourceCommand = async (input, context) => {
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
     resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.Tags != null && { tags: se___mapOf__string(input.Tags, context) }),
-    });
+    body = JSON.stringify(take(input, {
+        tags: [, (_) => _json(_), `Tags`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -488,20 +772,19 @@ export const se_UntagResourceCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateFlowCommand = async (input, context) => {
+export const se_UpdateBridgeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.Maintenance != null && { maintenance: se_UpdateMaintenance(input.Maintenance, context) }),
-        ...(input.SourceFailoverConfig != null && {
-            sourceFailoverConfig: se_UpdateFailoverConfig(input.SourceFailoverConfig, context),
-        }),
-    });
+    body = JSON.stringify(take(input, {
+        egressGatewayBridge: [, (_) => se_UpdateEgressGatewayBridgeRequest(_, context), `EgressGatewayBridge`],
+        ingressGatewayBridge: [, (_) => se_UpdateIngressGatewayBridgeRequest(_, context), `IngressGatewayBridge`],
+        sourceFailoverConfig: [, (_) => se_UpdateFailoverConfig(_, context), `SourceFailoverConfig`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -512,22 +795,19 @@ export const se_UpdateFlowCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateFlowEntitlementCommand = async (input, context) => {
+export const se_UpdateBridgeOutputCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/flows/{FlowArn}/entitlements/{EntitlementArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+        "/v1/bridges/{BridgeArn}/outputs/{OutputName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "OutputName", () => input.OutputName, "{OutputName}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.Description != null && { description: input.Description }),
-        ...(input.Encryption != null && { encryption: se_UpdateEncryption(input.Encryption, context) }),
-        ...(input.EntitlementStatus != null && { entitlementStatus: input.EntitlementStatus }),
-        ...(input.Subscribers != null && { subscribers: se___listOf__string(input.Subscribers, context) }),
-    });
+    body = JSON.stringify(take(input, {
+        networkOutput: [, (_) => se_UpdateBridgeNetworkOutputRequest(_, context), `NetworkOutput`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -538,23 +818,20 @@ export const se_UpdateFlowEntitlementCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateFlowMediaStreamCommand = async (input, context) => {
+export const se_UpdateBridgeSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
+        "/v1/bridges/{BridgeArn}/sources/{SourceName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "SourceName", () => input.SourceName, "{SourceName}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.Attributes != null && { attributes: se_MediaStreamAttributesRequest(input.Attributes, context) }),
-        ...(input.ClockRate != null && { clockRate: input.ClockRate }),
-        ...(input.Description != null && { description: input.Description }),
-        ...(input.MediaStreamType != null && { mediaStreamType: input.MediaStreamType }),
-        ...(input.VideoFormat != null && { videoFormat: input.VideoFormat }),
-    });
+    body = JSON.stringify(take(input, {
+        flowSource: [, (_) => se_UpdateBridgeFlowSourceRequest(_, context), `FlowSource`],
+        networkSource: [, (_) => se_UpdateBridgeNetworkSourceRequest(_, context), `NetworkSource`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -565,36 +842,17 @@ export const se_UpdateFlowMediaStreamCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateFlowOutputCommand = async (input, context) => {
+export const se_UpdateBridgeStateCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/outputs/{OutputArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "OutputArn", () => input.OutputArn, "{OutputArn}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/state";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.CidrAllowList != null && { cidrAllowList: se___listOf__string(input.CidrAllowList, context) }),
-        ...(input.Description != null && { description: input.Description }),
-        ...(input.Destination != null && { destination: input.Destination }),
-        ...(input.Encryption != null && { encryption: se_UpdateEncryption(input.Encryption, context) }),
-        ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
-        ...(input.MediaStreamOutputConfigurations != null && {
-            mediaStreamOutputConfigurations: se___listOfMediaStreamOutputConfigurationRequest(input.MediaStreamOutputConfigurations, context),
-        }),
-        ...(input.MinLatency != null && { minLatency: input.MinLatency }),
-        ...(input.Port != null && { port: input.Port }),
-        ...(input.Protocol != null && { protocol: input.Protocol }),
-        ...(input.RemoteId != null && { remoteId: input.RemoteId }),
-        ...(input.SenderControlPort != null && { senderControlPort: input.SenderControlPort }),
-        ...(input.SenderIpAddress != null && { senderIpAddress: input.SenderIpAddress }),
-        ...(input.SmoothingLatency != null && { smoothingLatency: input.SmoothingLatency }),
-        ...(input.StreamId != null && { streamId: input.StreamId }),
-        ...(input.VpcInterfaceAttachment != null && {
-            vpcInterfaceAttachment: se_VpcInterfaceAttachment(input.VpcInterfaceAttachment, context),
-        }),
-    });
+    body = JSON.stringify(take(input, {
+        desiredState: [, , `DesiredState`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -605,36 +863,18 @@ export const se_UpdateFlowOutputCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateFlowSourceCommand = async (input, context) => {
+export const se_UpdateFlowCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/source/{SourceArn}";
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}";
     resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "SourceArn", () => input.SourceArn, "{SourceArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.Decryption != null && { decryption: se_UpdateEncryption(input.Decryption, context) }),
-        ...(input.Description != null && { description: input.Description }),
-        ...(input.EntitlementArn != null && { entitlementArn: input.EntitlementArn }),
-        ...(input.IngestPort != null && { ingestPort: input.IngestPort }),
-        ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
-        ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
-        ...(input.MaxSyncBuffer != null && { maxSyncBuffer: input.MaxSyncBuffer }),
-        ...(input.MediaStreamSourceConfigurations != null && {
-            mediaStreamSourceConfigurations: se___listOfMediaStreamSourceConfigurationRequest(input.MediaStreamSourceConfigurations, context),
-        }),
-        ...(input.MinLatency != null && { minLatency: input.MinLatency }),
-        ...(input.Protocol != null && { protocol: input.Protocol }),
-        ...(input.SenderControlPort != null && { senderControlPort: input.SenderControlPort }),
-        ...(input.SenderIpAddress != null && { senderIpAddress: input.SenderIpAddress }),
-        ...(input.SourceListenerAddress != null && { sourceListenerAddress: input.SourceListenerAddress }),
-        ...(input.SourceListenerPort != null && { sourceListenerPort: input.SourceListenerPort }),
-        ...(input.StreamId != null && { streamId: input.StreamId }),
-        ...(input.VpcInterfaceName != null && { vpcInterfaceName: input.VpcInterfaceName }),
-        ...(input.WhitelistCidr != null && { whitelistCidr: input.WhitelistCidr }),
-    });
+    body = JSON.stringify(take(input, {
+        maintenance: [, (_) => se_UpdateMaintenance(_, context), `Maintenance`],
+        sourceFailoverConfig: [, (_) => se_UpdateFailoverConfig(_, context), `SourceFailoverConfig`],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -645,23 +885,180 @@ export const se_UpdateFlowSourceCommand = async (input, context) => {
         body,
     });
 };
-export const de_AddFlowMediaStreamsCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_AddFlowMediaStreamsCommandError(output, context);
+export const se_UpdateFlowEntitlementCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/flows/{FlowArn}/entitlements/{EntitlementArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [, , `Description`],
+        encryption: [, (_) => se_UpdateEncryption(_, context), `Encryption`],
+        entitlementStatus: [, , `EntitlementStatus`],
+        subscribers: [, (_) => _json(_), `Subscribers`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateFlowMediaStreamCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        attributes: [, (_) => se_MediaStreamAttributesRequest(_, context), `Attributes`],
+        clockRate: [, , `ClockRate`],
+        description: [, , `Description`],
+        mediaStreamType: [, , `MediaStreamType`],
+        videoFormat: [, , `VideoFormat`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateFlowOutputCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/outputs/{OutputArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "OutputArn", () => input.OutputArn, "{OutputArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        cidrAllowList: [, (_) => _json(_), `CidrAllowList`],
+        description: [, , `Description`],
+        destination: [, , `Destination`],
+        encryption: [, (_) => se_UpdateEncryption(_, context), `Encryption`],
+        maxLatency: [, , `MaxLatency`],
+        mediaStreamOutputConfigurations: [
+            ,
+            (_) => se___listOfMediaStreamOutputConfigurationRequest(_, context),
+            `MediaStreamOutputConfigurations`,
+        ],
+        minLatency: [, , `MinLatency`],
+        port: [, , `Port`],
+        protocol: [, , `Protocol`],
+        remoteId: [, , `RemoteId`],
+        senderControlPort: [, , `SenderControlPort`],
+        senderIpAddress: [, , `SenderIpAddress`],
+        smoothingLatency: [, , `SmoothingLatency`],
+        streamId: [, , `StreamId`],
+        vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateFlowSourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/source/{SourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "SourceArn", () => input.SourceArn, "{SourceArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        decryption: [, (_) => se_UpdateEncryption(_, context), `Decryption`],
+        description: [, , `Description`],
+        entitlementArn: [, , `EntitlementArn`],
+        gatewayBridgeSource: [, (_) => se_UpdateGatewayBridgeSourceRequest(_, context), `GatewayBridgeSource`],
+        ingestPort: [, , `IngestPort`],
+        maxBitrate: [, , `MaxBitrate`],
+        maxLatency: [, , `MaxLatency`],
+        maxSyncBuffer: [, , `MaxSyncBuffer`],
+        mediaStreamSourceConfigurations: [
+            ,
+            (_) => se___listOfMediaStreamSourceConfigurationRequest(_, context),
+            `MediaStreamSourceConfigurations`,
+        ],
+        minLatency: [, , `MinLatency`],
+        protocol: [, , `Protocol`],
+        senderControlPort: [, , `SenderControlPort`],
+        senderIpAddress: [, , `SenderIpAddress`],
+        sourceListenerAddress: [, , `SourceListenerAddress`],
+        sourceListenerPort: [, , `SourceListenerPort`],
+        streamId: [, , `StreamId`],
+        vpcInterfaceName: [, , `VpcInterfaceName`],
+        whitelistCidr: [, , `WhitelistCidr`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UpdateGatewayInstanceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/gateway-instances/{GatewayInstanceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        bridgePlacement: [, , `BridgePlacement`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const de_AddBridgeOutputsCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_AddBridgeOutputsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.mediaStreams != null) {
-        contents.MediaStreams = de___listOfMediaStream(data.mediaStreams, context);
-    }
+    const doc = take(data, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        Outputs: [, (_) => de___listOfBridgeOutput(_, context), `outputs`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_AddFlowMediaStreamsCommandError = async (output, context) => {
+const de_AddBridgeOutputsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -671,6 +1068,9 @@ const de_AddFlowMediaStreamsCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
@@ -688,43 +1088,41 @@ const de_AddFlowMediaStreamsCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_AddFlowOutputsCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_AddFlowOutputsCommandError(output, context);
+export const de_AddBridgeSourcesCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_AddBridgeSourcesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.outputs != null) {
-        contents.Outputs = de___listOfOutput(data.outputs, context);
-    }
+    const doc = take(data, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        Sources: [, (_) => de___listOfBridgeSource(_, context), `sources`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_AddFlowOutputsCommandError = async (output, context) => {
+const de_AddBridgeSourcesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AddFlowOutputs420Exception":
-        case "com.amazonaws.mediaconnect#AddFlowOutputs420Exception":
-            throw await de_AddFlowOutputs420ExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
@@ -742,31 +1140,29 @@ const de_AddFlowOutputsCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_AddFlowSourcesCommand = async (output, context) => {
+export const de_AddFlowMediaStreamsCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_AddFlowSourcesCommandError(output, context);
+        return de_AddFlowMediaStreamsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.sources != null) {
-        contents.Sources = de___listOfSource(data.sources, context);
-    }
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        MediaStreams: [, (_) => de___listOfMediaStream(_, context), `mediaStreams`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_AddFlowSourcesCommandError = async (output, context) => {
+const de_AddFlowMediaStreamsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -793,37 +1189,38 @@ const de_AddFlowSourcesCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_AddFlowVpcInterfacesCommand = async (output, context) => {
+export const de_AddFlowOutputsCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_AddFlowVpcInterfacesCommandError(output, context);
+        return de_AddFlowOutputsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.vpcInterfaces != null) {
-        contents.VpcInterfaces = de___listOfVpcInterface(data.vpcInterfaces, context);
-    }
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        Outputs: [, (_) => de___listOfOutput(_, context), `outputs`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_AddFlowVpcInterfacesCommandError = async (output, context) => {
+const de_AddFlowOutputsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "AddFlowOutputs420Exception":
+        case "com.amazonaws.mediaconnect#AddFlowOutputs420Exception":
+            throw await de_AddFlowOutputs420ExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
@@ -844,28 +1241,29 @@ const de_AddFlowVpcInterfacesCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_CreateFlowCommand = async (output, context) => {
+export const de_AddFlowSourcesCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_CreateFlowCommandError(output, context);
+        return de_AddFlowSourcesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flow != null) {
-        contents.Flow = de_Flow(data.flow, context);
-    }
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        Sources: [, (_) => de___listOfSource(_, context), `sources`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_CreateFlowCommandError = async (output, context) => {
+const de_AddFlowSourcesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -875,15 +1273,15 @@ const de_CreateFlowCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "CreateFlow420Exception":
-        case "com.amazonaws.mediaconnect#CreateFlow420Exception":
-            throw await de_CreateFlow420ExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -892,31 +1290,29 @@ const de_CreateFlowCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_DeleteFlowCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteFlowCommandError(output, context);
+export const de_AddFlowVpcInterfacesCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_AddFlowVpcInterfacesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.status != null) {
-        contents.Status = __expectString(data.status);
-    }
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        VpcInterfaces: [, (_) => de___listOfVpcInterface(_, context), `vpcInterfaces`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteFlowCommandError = async (output, context) => {
+const de_AddFlowVpcInterfacesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -943,31 +1339,28 @@ const de_DeleteFlowCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_DescribeFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeFlowCommandError(output, context);
+export const de_CreateBridgeCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_CreateBridgeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flow != null) {
-        contents.Flow = de_Flow(data.flow, context);
-    }
-    if (data.messages != null) {
-        contents.Messages = de_Messages(data.messages, context);
-    }
+    const doc = take(data, {
+        Bridge: [, (_) => de_Bridge(_, context), `bridge`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeFlowCommandError = async (output, context) => {
+const de_CreateBridgeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -977,15 +1370,18 @@ const de_DescribeFlowCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "CreateBridge420Exception":
+        case "com.amazonaws.mediaconnect#CreateBridge420Exception":
+            throw await de_CreateBridge420ExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -994,28 +1390,28 @@ const de_DescribeFlowCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_DescribeOfferingCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeOfferingCommandError(output, context);
+export const de_CreateFlowCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_CreateFlowCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.offering != null) {
-        contents.Offering = de_Offering(data.offering, context);
-    }
+    const doc = take(data, {
+        Flow: [, (_) => de_Flow(_, context), `flow`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeOfferingCommandError = async (output, context) => {
+const de_CreateFlowCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1025,12 +1421,15 @@ const de_DescribeOfferingCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "CreateFlow420Exception":
+        case "com.amazonaws.mediaconnect#CreateFlow420Exception":
+            throw await de_CreateFlow420ExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1039,28 +1438,28 @@ const de_DescribeOfferingCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_DescribeReservationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeReservationCommandError(output, context);
+export const de_CreateGatewayCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_CreateGatewayCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.reservation != null) {
-        contents.Reservation = de_Reservation(data.reservation, context);
-    }
+    const doc = take(data, {
+        Gateway: [, (_) => de_Gateway(_, context), `gateway`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeReservationCommandError = async (output, context) => {
+const de_CreateGatewayCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1070,12 +1469,18 @@ const de_DescribeReservationCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "CreateGateway420Exception":
+        case "com.amazonaws.mediaconnect#CreateGateway420Exception":
+            throw await de_CreateGateway420ExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1084,31 +1489,28 @@ const de_DescribeReservationCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_GrantFlowEntitlementsCommand = async (output, context) => {
+export const de_DeleteBridgeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GrantFlowEntitlementsCommandError(output, context);
+        return de_DeleteBridgeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.entitlements != null) {
-        contents.Entitlements = de___listOfEntitlement(data.entitlements, context);
-    }
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
+    const doc = take(data, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_GrantFlowEntitlementsCommandError = async (output, context) => {
+const de_DeleteBridgeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1118,12 +1520,12 @@ const de_GrantFlowEntitlementsCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "GrantFlowEntitlements420Exception":
-        case "com.amazonaws.mediaconnect#GrantFlowEntitlements420Exception":
-            throw await de_GrantFlowEntitlements420ExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
@@ -1138,31 +1540,29 @@ const de_GrantFlowEntitlementsCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_ListEntitlementsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListEntitlementsCommandError(output, context);
+export const de_DeleteFlowCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_DeleteFlowCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.entitlements != null) {
-        contents.Entitlements = de___listOfListedEntitlement(data.entitlements, context);
-    }
-    if (data.nextToken != null) {
-        contents.NextToken = __expectString(data.nextToken);
-    }
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        Status: [, __expectString, `status`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_ListEntitlementsCommandError = async (output, context) => {
+const de_DeleteFlowCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1172,9 +1572,15 @@ const de_ListEntitlementsCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1183,31 +1589,28 @@ const de_ListEntitlementsCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_ListFlowsCommand = async (output, context) => {
+export const de_DeleteGatewayCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListFlowsCommandError(output, context);
+        return de_DeleteGatewayCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flows != null) {
-        contents.Flows = de___listOfListedFlow(data.flows, context);
-    }
-    if (data.nextToken != null) {
-        contents.NextToken = __expectString(data.nextToken);
-    }
+    const doc = take(data, {
+        GatewayArn: [, __expectString, `gatewayArn`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_ListFlowsCommandError = async (output, context) => {
+const de_DeleteGatewayCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1217,9 +1620,18 @@ const de_ListFlowsCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1228,31 +1640,29 @@ const de_ListFlowsCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_ListOfferingsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListOfferingsCommandError(output, context);
+export const de_DeregisterGatewayInstanceCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_DeregisterGatewayInstanceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.nextToken != null) {
-        contents.NextToken = __expectString(data.nextToken);
-    }
-    if (data.offerings != null) {
-        contents.Offerings = de___listOfOffering(data.offerings, context);
-    }
+    const doc = take(data, {
+        GatewayInstanceArn: [, __expectString, `gatewayInstanceArn`],
+        InstanceState: [, __expectString, `instanceState`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_ListOfferingsCommandError = async (output, context) => {
+const de_DeregisterGatewayInstanceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1262,9 +1672,18 @@ const de_ListOfferingsCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1273,31 +1692,28 @@ const de_ListOfferingsCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_ListReservationsCommand = async (output, context) => {
+export const de_DescribeBridgeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListReservationsCommandError(output, context);
+        return de_DescribeBridgeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.nextToken != null) {
-        contents.NextToken = __expectString(data.nextToken);
-    }
-    if (data.reservations != null) {
-        contents.Reservations = de___listOfReservation(data.reservations, context);
-    }
+    const doc = take(data, {
+        Bridge: [, (_) => de_Bridge(_, context), `bridge`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_ListReservationsCommandError = async (output, context) => {
+const de_DescribeBridgeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1307,9 +1723,18 @@ const de_ListReservationsCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1318,28 +1743,29 @@ const de_ListReservationsCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_ListTagsForResourceCommand = async (output, context) => {
+export const de_DescribeFlowCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListTagsForResourceCommandError(output, context);
+        return de_DescribeFlowCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.tags != null) {
-        contents.Tags = de___mapOf__string(data.tags, context);
-    }
+    const doc = take(data, {
+        Flow: [, (_) => de_Flow(_, context), `flow`],
+        Messages: [, (_) => de_Messages(_, context), `messages`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_ListTagsForResourceCommandError = async (output, context) => {
+const de_DescribeFlowCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1349,36 +1775,45 @@ const de_ListTagsForResourceCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.mediaconnect#NotFoundException":
             throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_PurchaseOfferingCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_PurchaseOfferingCommandError(output, context);
+export const de_DescribeGatewayCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeGatewayCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.reservation != null) {
-        contents.Reservation = de_Reservation(data.reservation, context);
-    }
+    const doc = take(data, {
+        Gateway: [, (_) => de_Gateway(_, context), `gateway`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_PurchaseOfferingCommandError = async (output, context) => {
+const de_DescribeGatewayCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1388,6 +1823,9 @@ const de_PurchaseOfferingCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
@@ -1405,31 +1843,28 @@ const de_PurchaseOfferingCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_RemoveFlowMediaStreamCommand = async (output, context) => {
+export const de_DescribeGatewayInstanceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_RemoveFlowMediaStreamCommandError(output, context);
+        return de_DescribeGatewayInstanceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.mediaStreamName != null) {
-        contents.MediaStreamName = __expectString(data.mediaStreamName);
-    }
+    const doc = take(data, {
+        GatewayInstance: [, (_) => de_GatewayInstance(_, context), `gatewayInstance`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_RemoveFlowMediaStreamCommandError = async (output, context) => {
+const de_DescribeGatewayInstanceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1439,6 +1874,9 @@ const de_RemoveFlowMediaStreamCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
@@ -1456,31 +1894,28 @@ const de_RemoveFlowMediaStreamCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_RemoveFlowOutputCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_RemoveFlowOutputCommandError(output, context);
+export const de_DescribeOfferingCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeOfferingCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.outputArn != null) {
-        contents.OutputArn = __expectString(data.outputArn);
-    }
+    const doc = take(data, {
+        Offering: [, (_) => de_Offering(_, context), `offering`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_RemoveFlowOutputCommandError = async (output, context) => {
+const de_DescribeOfferingCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1490,9 +1925,6 @@ const de_RemoveFlowOutputCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.mediaconnect#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
@@ -1507,31 +1939,28 @@ const de_RemoveFlowOutputCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_RemoveFlowSourceCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_RemoveFlowSourceCommandError(output, context);
+export const de_DescribeReservationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeReservationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.sourceArn != null) {
-        contents.SourceArn = __expectString(data.sourceArn);
-    }
+    const doc = take(data, {
+        Reservation: [, (_) => de_Reservation(_, context), `reservation`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_RemoveFlowSourceCommandError = async (output, context) => {
+const de_DescribeReservationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1541,9 +1970,6 @@ const de_RemoveFlowSourceCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.mediaconnect#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
@@ -1558,34 +1984,29 @@ const de_RemoveFlowSourceCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_RemoveFlowVpcInterfaceCommand = async (output, context) => {
+export const de_GrantFlowEntitlementsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_RemoveFlowVpcInterfaceCommandError(output, context);
+        return de_GrantFlowEntitlementsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.nonDeletedNetworkInterfaceIds != null) {
-        contents.NonDeletedNetworkInterfaceIds = de___listOf__string(data.nonDeletedNetworkInterfaceIds, context);
-    }
-    if (data.vpcInterfaceName != null) {
-        contents.VpcInterfaceName = __expectString(data.vpcInterfaceName);
-    }
+    const doc = take(data, {
+        Entitlements: [, (_) => de___listOfEntitlement(_, context), `entitlements`],
+        FlowArn: [, __expectString, `flowArn`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_RemoveFlowVpcInterfaceCommandError = async (output, context) => {
+const de_GrantFlowEntitlementsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1598,6 +2019,9 @@ const de_RemoveFlowVpcInterfaceCommandError = async (output, context) => {
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "GrantFlowEntitlements420Exception":
+        case "com.amazonaws.mediaconnect#GrantFlowEntitlements420Exception":
+            throw await de_GrantFlowEntitlements420ExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
@@ -1612,31 +2036,29 @@ const de_RemoveFlowVpcInterfaceCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_RevokeFlowEntitlementCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_RevokeFlowEntitlementCommandError(output, context);
+export const de_ListBridgesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListBridgesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.entitlementArn != null) {
-        contents.EntitlementArn = __expectString(data.entitlementArn);
-    }
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
+    const doc = take(data, {
+        Bridges: [, (_) => de___listOfListedBridge(_, context), `bridges`],
+        NextToken: [, __expectString, `nextToken`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_RevokeFlowEntitlementCommandError = async (output, context) => {
+const de_ListBridgesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1646,15 +2068,12 @@ const de_RevokeFlowEntitlementCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.mediaconnect#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1663,31 +2082,29 @@ const de_RevokeFlowEntitlementCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_StartFlowCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_StartFlowCommandError(output, context);
+export const de_ListEntitlementsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListEntitlementsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.status != null) {
-        contents.Status = __expectString(data.status);
-    }
+    const doc = take(data, {
+        Entitlements: [, (_) => de___listOfListedEntitlement(_, context), `entitlements`],
+        NextToken: [, __expectString, `nextToken`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_StartFlowCommandError = async (output, context) => {
+const de_ListEntitlementsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1697,15 +2114,9 @@ const de_StartFlowCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.mediaconnect#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1714,31 +2125,29 @@ const de_StartFlowCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_StopFlowCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_StopFlowCommandError(output, context);
+export const de_ListFlowsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListFlowsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.status != null) {
-        contents.Status = __expectString(data.status);
-    }
+    const doc = take(data, {
+        Flows: [, (_) => de___listOfListedFlow(_, context), `flows`],
+        NextToken: [, __expectString, `nextToken`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_StopFlowCommandError = async (output, context) => {
+const de_ListFlowsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1748,15 +2157,9 @@ const de_StopFlowCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.mediaconnect#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1765,25 +2168,29 @@ const de_StopFlowCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_TagResourceCommandError(output, context);
+export const de_ListGatewayInstancesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListGatewayInstancesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Instances: [, (_) => de___listOfListedGatewayInstance(_, context), `instances`],
+        NextToken: [, __expectString, `nextToken`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_TagResourceCommandError = async (output, context) => {
+const de_ListGatewayInstancesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1793,33 +2200,43 @@ const de_TagResourceCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_UntagResourceCommandError(output, context);
+export const de_ListGatewaysCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListGatewaysCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Gateways: [, (_) => de___listOfListedGateway(_, context), `gateways`],
+        NextToken: [, __expectString, `nextToken`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_UntagResourceCommandError = async (output, context) => {
+const de_ListGatewaysCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1829,36 +2246,43 @@ const de_UntagResourceCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_UpdateFlowCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateFlowCommandError(output, context);
+export const de_ListOfferingsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListOfferingsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flow != null) {
-        contents.Flow = de_Flow(data.flow, context);
-    }
+    const doc = take(data, {
+        NextToken: [, __expectString, `nextToken`],
+        Offerings: [, (_) => de___listOfOffering(_, context), `offerings`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateFlowCommandError = async (output, context) => {
+const de_ListOfferingsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1868,15 +2292,9 @@ const de_UpdateFlowCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.mediaconnect#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1885,31 +2303,29 @@ const de_UpdateFlowCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_UpdateFlowEntitlementCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateFlowEntitlementCommandError(output, context);
+export const de_ListReservationsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListReservationsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.entitlement != null) {
-        contents.Entitlement = de_Entitlement(data.entitlement, context);
-    }
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
+    const doc = take(data, {
+        NextToken: [, __expectString, `nextToken`],
+        Reservations: [, (_) => de___listOfReservation(_, context), `reservations`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateFlowEntitlementCommandError = async (output, context) => {
+const de_ListReservationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1919,15 +2335,9 @@ const de_UpdateFlowEntitlementCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.mediaconnect#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.mediaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.mediaconnect#ServiceUnavailableException":
             throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -1936,31 +2346,67 @@ const de_UpdateFlowEntitlementCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_UpdateFlowMediaStreamCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateFlowMediaStreamCommandError(output, context);
+export const de_ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
+    const doc = take(data, {
+        Tags: [, _json, `tags`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
     }
-    if (data.mediaStream != null) {
-        contents.MediaStream = de_MediaStream(data.mediaStream, context);
+};
+export const de_PurchaseOfferingCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_PurchaseOfferingCommandError(output, context);
     }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Reservation: [, (_) => de_Reservation(_, context), `reservation`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateFlowMediaStreamCommandError = async (output, context) => {
+const de_PurchaseOfferingCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1987,31 +2433,29 @@ const de_UpdateFlowMediaStreamCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_UpdateFlowOutputCommand = async (output, context) => {
+export const de_RemoveBridgeOutputCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateFlowOutputCommandError(output, context);
+        return de_RemoveBridgeOutputCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.output != null) {
-        contents.Output = de_Output(data.output, context);
-    }
+    const doc = take(data, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        OutputName: [, __expectString, `outputName`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateFlowOutputCommandError = async (output, context) => {
+const de_RemoveBridgeOutputCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2021,6 +2465,9 @@ const de_UpdateFlowOutputCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
@@ -2038,31 +2485,29 @@ const de_UpdateFlowOutputCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-export const de_UpdateFlowSourceCommand = async (output, context) => {
+export const de_RemoveBridgeSourceCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateFlowSourceCommandError(output, context);
+        return de_RemoveBridgeSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.source != null) {
-        contents.Source = de_Source(data.source, context);
-    }
+    const doc = take(data, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        SourceName: [, __expectString, `sourceName`],
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateFlowSourceCommandError = async (output, context) => {
+const de_RemoveBridgeSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2072,6 +2517,9 @@ const de_UpdateFlowSourceCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.mediaconnect#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.mediaconnect#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
@@ -2089,34 +2537,978 @@ const de_UpdateFlowSourceCommandError = async (output, context) => {
             throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            throwDefaultError({
+            return throwDefaultError({
                 output,
                 parsedBody,
-                exceptionCtor: __BaseException,
                 errorCode,
             });
     }
 };
-const map = __map;
-const de_AddFlowOutputs420ExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
+export const de_RemoveFlowMediaStreamCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_RemoveFlowMediaStreamCommandError(output, context);
     }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        MediaStreamName: [, __expectString, `mediaStreamName`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_RemoveFlowMediaStreamCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_RemoveFlowOutputCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_RemoveFlowOutputCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        OutputArn: [, __expectString, `outputArn`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_RemoveFlowOutputCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_RemoveFlowSourceCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_RemoveFlowSourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        SourceArn: [, __expectString, `sourceArn`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_RemoveFlowSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_RemoveFlowVpcInterfaceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_RemoveFlowVpcInterfaceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        NonDeletedNetworkInterfaceIds: [, _json, `nonDeletedNetworkInterfaceIds`],
+        VpcInterfaceName: [, __expectString, `vpcInterfaceName`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_RemoveFlowVpcInterfaceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_RevokeFlowEntitlementCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_RevokeFlowEntitlementCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        EntitlementArn: [, __expectString, `entitlementArn`],
+        FlowArn: [, __expectString, `flowArn`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_RevokeFlowEntitlementCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_StartFlowCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_StartFlowCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        Status: [, __expectString, `status`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_StartFlowCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_StopFlowCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_StopFlowCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        Status: [, __expectString, `status`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_StopFlowCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_TagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_UntagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateBridgeCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateBridgeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Bridge: [, (_) => de_Bridge(_, context), `bridge`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateBridgeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateBridgeOutputCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateBridgeOutputCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        Output: [, (_) => de_BridgeOutput(_, context), `output`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateBridgeOutputCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateBridgeSourceCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateBridgeSourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        Source: [, (_) => de_BridgeSource(_, context), `source`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateBridgeSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateBridgeStateCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateBridgeStateCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        DesiredState: [, __expectString, `desiredState`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateBridgeStateCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateFlowCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateFlowCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Flow: [, (_) => de_Flow(_, context), `flow`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateFlowCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateFlowEntitlementCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateFlowEntitlementCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Entitlement: [, (_) => de_Entitlement(_, context), `entitlement`],
+        FlowArn: [, __expectString, `flowArn`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateFlowEntitlementCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateFlowMediaStreamCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateFlowMediaStreamCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        MediaStream: [, (_) => de_MediaStream(_, context), `mediaStream`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateFlowMediaStreamCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateFlowOutputCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateFlowOutputCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        Output: [, (_) => de_Output(_, context), `output`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateFlowOutputCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateFlowSourceCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_UpdateFlowSourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        FlowArn: [, __expectString, `flowArn`],
+        Source: [, (_) => de_Source(_, context), `source`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateFlowSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_UpdateGatewayInstanceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateGatewayInstanceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        BridgePlacement: [, __expectString, `bridgePlacement`],
+        GatewayInstanceArn: [, __expectString, `gatewayInstanceArn`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateGatewayInstanceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.mediaconnect#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mediaconnect#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.mediaconnect#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.mediaconnect#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.mediaconnect#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.mediaconnect#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const throwDefaultError = withBaseException(__BaseException);
+const de_AddFlowOutputs420ExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
     const exception = new AddFlowOutputs420Exception({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_BadRequestExceptionRes = async (parsedOutput, context) => {
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
+    const exception = new BadRequestException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_CreateBridge420ExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
-    }
-    const exception = new BadRequestException({
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
+    const exception = new CreateBridge420Exception({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
     });
@@ -2125,21 +3517,36 @@ const de_BadRequestExceptionRes = async (parsedOutput, context) => {
 const de_CreateFlow420ExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
-    }
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
     const exception = new CreateFlow420Exception({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_CreateGateway420ExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
+    const exception = new CreateGateway420Exception({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
-    }
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
     const exception = new ForbiddenException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
@@ -2149,9 +3556,10 @@ const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
 const de_GrantFlowEntitlements420ExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
-    }
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
     const exception = new GrantFlowEntitlements420Exception({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
@@ -2161,9 +3569,10 @@ const de_GrantFlowEntitlements420ExceptionRes = async (parsedOutput, context) =>
 const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
-    }
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
     const exception = new InternalServerErrorException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
@@ -2173,9 +3582,10 @@ const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
 const de_NotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
-    }
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
     const exception = new NotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
@@ -2185,9 +3595,10 @@ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
 const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
-    }
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
     const exception = new ServiceUnavailableException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
@@ -2197,20 +3608,28 @@ const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
 const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.Message = __expectString(data.message);
-    }
+    const doc = take(data, {
+        Message: [, __expectString, `message`],
+    });
+    Object.assign(contents, doc);
     const exception = new TooManyRequestsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const se___listOf__string = (input, context) => {
+const se___listOfAddBridgeOutputRequest = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_AddBridgeOutputRequest(entry, context);
+    });
+};
+const se___listOfAddBridgeSourceRequest = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return entry;
+        return se_AddBridgeSourceRequest(entry, context);
     });
 };
 const se___listOfAddMediaStreamRequest = (input, context) => {
@@ -2234,6 +3653,13 @@ const se___listOfDestinationConfigurationRequest = (input, context) => {
         return se_DestinationConfigurationRequest(entry, context);
     });
 };
+const se___listOfGatewayNetwork = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_GatewayNetwork(entry, context);
+    });
+};
 const se___listOfGrantEntitlementRequest = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -2276,233 +3702,324 @@ const se___listOfVpcInterfaceRequest = (input, context) => {
         return se_VpcInterfaceRequest(entry, context);
     });
 };
-const se___mapOf__string = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = value;
-        return acc;
-    }, {});
+const se_AddBridgeFlowSourceRequest = (input, context) => {
+    return take(input, {
+        flowArn: [, , `FlowArn`],
+        flowVpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `FlowVpcInterfaceAttachment`],
+        name: [, , `Name`],
+    });
+};
+const se_AddBridgeNetworkOutputRequest = (input, context) => {
+    return take(input, {
+        ipAddress: [, , `IpAddress`],
+        name: [, , `Name`],
+        networkName: [, , `NetworkName`],
+        port: [, , `Port`],
+        protocol: [, , `Protocol`],
+        ttl: [, , `Ttl`],
+    });
+};
+const se_AddBridgeNetworkSourceRequest = (input, context) => {
+    return take(input, {
+        multicastIp: [, , `MulticastIp`],
+        name: [, , `Name`],
+        networkName: [, , `NetworkName`],
+        port: [, , `Port`],
+        protocol: [, , `Protocol`],
+    });
+};
+const se_AddBridgeOutputRequest = (input, context) => {
+    return take(input, {
+        networkOutput: [, (_) => se_AddBridgeNetworkOutputRequest(_, context), `NetworkOutput`],
+    });
+};
+const se_AddBridgeSourceRequest = (input, context) => {
+    return take(input, {
+        flowSource: [, (_) => se_AddBridgeFlowSourceRequest(_, context), `FlowSource`],
+        networkSource: [, (_) => se_AddBridgeNetworkSourceRequest(_, context), `NetworkSource`],
+    });
+};
+const se_AddEgressGatewayBridgeRequest = (input, context) => {
+    return take(input, {
+        maxBitrate: [, , `MaxBitrate`],
+    });
+};
+const se_AddIngressGatewayBridgeRequest = (input, context) => {
+    return take(input, {
+        maxBitrate: [, , `MaxBitrate`],
+        maxOutputs: [, , `MaxOutputs`],
+    });
 };
 const se_AddMaintenance = (input, context) => {
-    return {
-        ...(input.MaintenanceDay != null && { maintenanceDay: input.MaintenanceDay }),
-        ...(input.MaintenanceStartHour != null && { maintenanceStartHour: input.MaintenanceStartHour }),
-    };
+    return take(input, {
+        maintenanceDay: [, , `MaintenanceDay`],
+        maintenanceStartHour: [, , `MaintenanceStartHour`],
+    });
 };
 const se_AddMediaStreamRequest = (input, context) => {
-    return {
-        ...(input.Attributes != null && { attributes: se_MediaStreamAttributesRequest(input.Attributes, context) }),
-        ...(input.ClockRate != null && { clockRate: input.ClockRate }),
-        ...(input.Description != null && { description: input.Description }),
-        ...(input.MediaStreamId != null && { mediaStreamId: input.MediaStreamId }),
-        ...(input.MediaStreamName != null && { mediaStreamName: input.MediaStreamName }),
-        ...(input.MediaStreamType != null && { mediaStreamType: input.MediaStreamType }),
-        ...(input.VideoFormat != null && { videoFormat: input.VideoFormat }),
-    };
+    return take(input, {
+        attributes: [, (_) => se_MediaStreamAttributesRequest(_, context), `Attributes`],
+        clockRate: [, , `ClockRate`],
+        description: [, , `Description`],
+        mediaStreamId: [, , `MediaStreamId`],
+        mediaStreamName: [, , `MediaStreamName`],
+        mediaStreamType: [, , `MediaStreamType`],
+        videoFormat: [, , `VideoFormat`],
+    });
 };
 const se_AddOutputRequest = (input, context) => {
-    return {
-        ...(input.CidrAllowList != null && { cidrAllowList: se___listOf__string(input.CidrAllowList, context) }),
-        ...(input.Description != null && { description: input.Description }),
-        ...(input.Destination != null && { destination: input.Destination }),
-        ...(input.Encryption != null && { encryption: se_Encryption(input.Encryption, context) }),
-        ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
-        ...(input.MediaStreamOutputConfigurations != null && {
-            mediaStreamOutputConfigurations: se___listOfMediaStreamOutputConfigurationRequest(input.MediaStreamOutputConfigurations, context),
-        }),
-        ...(input.MinLatency != null && { minLatency: input.MinLatency }),
-        ...(input.Name != null && { name: input.Name }),
-        ...(input.Port != null && { port: input.Port }),
-        ...(input.Protocol != null && { protocol: input.Protocol }),
-        ...(input.RemoteId != null && { remoteId: input.RemoteId }),
-        ...(input.SenderControlPort != null && { senderControlPort: input.SenderControlPort }),
-        ...(input.SmoothingLatency != null && { smoothingLatency: input.SmoothingLatency }),
-        ...(input.StreamId != null && { streamId: input.StreamId }),
-        ...(input.VpcInterfaceAttachment != null && {
-            vpcInterfaceAttachment: se_VpcInterfaceAttachment(input.VpcInterfaceAttachment, context),
-        }),
-    };
+    return take(input, {
+        cidrAllowList: [, _json, `CidrAllowList`],
+        description: [, , `Description`],
+        destination: [, , `Destination`],
+        encryption: [, (_) => se_Encryption(_, context), `Encryption`],
+        maxLatency: [, , `MaxLatency`],
+        mediaStreamOutputConfigurations: [
+            ,
+            (_) => se___listOfMediaStreamOutputConfigurationRequest(_, context),
+            `MediaStreamOutputConfigurations`,
+        ],
+        minLatency: [, , `MinLatency`],
+        name: [, , `Name`],
+        port: [, , `Port`],
+        protocol: [, , `Protocol`],
+        remoteId: [, , `RemoteId`],
+        senderControlPort: [, , `SenderControlPort`],
+        smoothingLatency: [, , `SmoothingLatency`],
+        streamId: [, , `StreamId`],
+        vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
+    });
 };
 const se_DestinationConfigurationRequest = (input, context) => {
-    return {
-        ...(input.DestinationIp != null && { destinationIp: input.DestinationIp }),
-        ...(input.DestinationPort != null && { destinationPort: input.DestinationPort }),
-        ...(input.Interface != null && { interface: se_InterfaceRequest(input.Interface, context) }),
-    };
+    return take(input, {
+        destinationIp: [, , `DestinationIp`],
+        destinationPort: [, , `DestinationPort`],
+        interface: [, (_) => se_InterfaceRequest(_, context), `Interface`],
+    });
 };
 const se_EncodingParametersRequest = (input, context) => {
-    return {
-        ...(input.CompressionFactor != null && { compressionFactor: __serializeFloat(input.CompressionFactor) }),
-        ...(input.EncoderProfile != null && { encoderProfile: input.EncoderProfile }),
-    };
+    return take(input, {
+        compressionFactor: [, __serializeFloat, `CompressionFactor`],
+        encoderProfile: [, , `EncoderProfile`],
+    });
 };
 const se_Encryption = (input, context) => {
-    return {
-        ...(input.Algorithm != null && { algorithm: input.Algorithm }),
-        ...(input.ConstantInitializationVector != null && {
-            constantInitializationVector: input.ConstantInitializationVector,
-        }),
-        ...(input.DeviceId != null && { deviceId: input.DeviceId }),
-        ...(input.KeyType != null && { keyType: input.KeyType }),
-        ...(input.Region != null && { region: input.Region }),
-        ...(input.ResourceId != null && { resourceId: input.ResourceId }),
-        ...(input.RoleArn != null && { roleArn: input.RoleArn }),
-        ...(input.SecretArn != null && { secretArn: input.SecretArn }),
-        ...(input.Url != null && { url: input.Url }),
-    };
+    return take(input, {
+        algorithm: [, , `Algorithm`],
+        constantInitializationVector: [, , `ConstantInitializationVector`],
+        deviceId: [, , `DeviceId`],
+        keyType: [, , `KeyType`],
+        region: [, , `Region`],
+        resourceId: [, , `ResourceId`],
+        roleArn: [, , `RoleArn`],
+        secretArn: [, , `SecretArn`],
+        url: [, , `Url`],
+    });
 };
 const se_FailoverConfig = (input, context) => {
-    return {
-        ...(input.FailoverMode != null && { failoverMode: input.FailoverMode }),
-        ...(input.RecoveryWindow != null && { recoveryWindow: input.RecoveryWindow }),
-        ...(input.SourcePriority != null && { sourcePriority: se_SourcePriority(input.SourcePriority, context) }),
-        ...(input.State != null && { state: input.State }),
-    };
+    return take(input, {
+        failoverMode: [, , `FailoverMode`],
+        recoveryWindow: [, , `RecoveryWindow`],
+        sourcePriority: [, (_) => se_SourcePriority(_, context), `SourcePriority`],
+        state: [, , `State`],
+    });
 };
 const se_FmtpRequest = (input, context) => {
-    return {
-        ...(input.ChannelOrder != null && { channelOrder: input.ChannelOrder }),
-        ...(input.Colorimetry != null && { colorimetry: input.Colorimetry }),
-        ...(input.ExactFramerate != null && { exactFramerate: input.ExactFramerate }),
-        ...(input.Par != null && { par: input.Par }),
-        ...(input.Range != null && { range: input.Range }),
-        ...(input.ScanMode != null && { scanMode: input.ScanMode }),
-        ...(input.Tcs != null && { tcs: input.Tcs }),
-    };
+    return take(input, {
+        channelOrder: [, , `ChannelOrder`],
+        colorimetry: [, , `Colorimetry`],
+        exactFramerate: [, , `ExactFramerate`],
+        par: [, , `Par`],
+        range: [, , `Range`],
+        scanMode: [, , `ScanMode`],
+        tcs: [, , `Tcs`],
+    });
+};
+const se_GatewayNetwork = (input, context) => {
+    return take(input, {
+        cidrBlock: [, , `CidrBlock`],
+        name: [, , `Name`],
+    });
 };
 const se_GrantEntitlementRequest = (input, context) => {
-    return {
-        ...(input.DataTransferSubscriberFeePercent != null && {
-            dataTransferSubscriberFeePercent: input.DataTransferSubscriberFeePercent,
-        }),
-        ...(input.Description != null && { description: input.Description }),
-        ...(input.Encryption != null && { encryption: se_Encryption(input.Encryption, context) }),
-        ...(input.EntitlementStatus != null && { entitlementStatus: input.EntitlementStatus }),
-        ...(input.Name != null && { name: input.Name }),
-        ...(input.Subscribers != null && { subscribers: se___listOf__string(input.Subscribers, context) }),
-    };
+    return take(input, {
+        dataTransferSubscriberFeePercent: [, , `DataTransferSubscriberFeePercent`],
+        description: [, , `Description`],
+        encryption: [, (_) => se_Encryption(_, context), `Encryption`],
+        entitlementStatus: [, , `EntitlementStatus`],
+        name: [, , `Name`],
+        subscribers: [, _json, `Subscribers`],
+    });
 };
 const se_InputConfigurationRequest = (input, context) => {
-    return {
-        ...(input.InputPort != null && { inputPort: input.InputPort }),
-        ...(input.Interface != null && { interface: se_InterfaceRequest(input.Interface, context) }),
-    };
+    return take(input, {
+        inputPort: [, , `InputPort`],
+        interface: [, (_) => se_InterfaceRequest(_, context), `Interface`],
+    });
 };
 const se_InterfaceRequest = (input, context) => {
-    return {
-        ...(input.Name != null && { name: input.Name }),
-    };
+    return take(input, {
+        name: [, , `Name`],
+    });
 };
 const se_MediaStreamAttributesRequest = (input, context) => {
-    return {
-        ...(input.Fmtp != null && { fmtp: se_FmtpRequest(input.Fmtp, context) }),
-        ...(input.Lang != null && { lang: input.Lang }),
-    };
+    return take(input, {
+        fmtp: [, (_) => se_FmtpRequest(_, context), `Fmtp`],
+        lang: [, , `Lang`],
+    });
 };
 const se_MediaStreamOutputConfigurationRequest = (input, context) => {
-    return {
-        ...(input.DestinationConfigurations != null && {
-            destinationConfigurations: se___listOfDestinationConfigurationRequest(input.DestinationConfigurations, context),
-        }),
-        ...(input.EncodingName != null && { encodingName: input.EncodingName }),
-        ...(input.EncodingParameters != null && {
-            encodingParameters: se_EncodingParametersRequest(input.EncodingParameters, context),
-        }),
-        ...(input.MediaStreamName != null && { mediaStreamName: input.MediaStreamName }),
-    };
+    return take(input, {
+        destinationConfigurations: [
+            ,
+            (_) => se___listOfDestinationConfigurationRequest(_, context),
+            `DestinationConfigurations`,
+        ],
+        encodingName: [, , `EncodingName`],
+        encodingParameters: [, (_) => se_EncodingParametersRequest(_, context), `EncodingParameters`],
+        mediaStreamName: [, , `MediaStreamName`],
+    });
 };
 const se_MediaStreamSourceConfigurationRequest = (input, context) => {
-    return {
-        ...(input.EncodingName != null && { encodingName: input.EncodingName }),
-        ...(input.InputConfigurations != null && {
-            inputConfigurations: se___listOfInputConfigurationRequest(input.InputConfigurations, context),
-        }),
-        ...(input.MediaStreamName != null && { mediaStreamName: input.MediaStreamName }),
-    };
+    return take(input, {
+        encodingName: [, , `EncodingName`],
+        inputConfigurations: [, (_) => se___listOfInputConfigurationRequest(_, context), `InputConfigurations`],
+        mediaStreamName: [, , `MediaStreamName`],
+    });
+};
+const se_SetGatewayBridgeSourceRequest = (input, context) => {
+    return take(input, {
+        bridgeArn: [, , `BridgeArn`],
+        vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
+    });
 };
 const se_SetSourceRequest = (input, context) => {
-    return {
-        ...(input.Decryption != null && { decryption: se_Encryption(input.Decryption, context) }),
-        ...(input.Description != null && { description: input.Description }),
-        ...(input.EntitlementArn != null && { entitlementArn: input.EntitlementArn }),
-        ...(input.IngestPort != null && { ingestPort: input.IngestPort }),
-        ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
-        ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
-        ...(input.MaxSyncBuffer != null && { maxSyncBuffer: input.MaxSyncBuffer }),
-        ...(input.MediaStreamSourceConfigurations != null && {
-            mediaStreamSourceConfigurations: se___listOfMediaStreamSourceConfigurationRequest(input.MediaStreamSourceConfigurations, context),
-        }),
-        ...(input.MinLatency != null && { minLatency: input.MinLatency }),
-        ...(input.Name != null && { name: input.Name }),
-        ...(input.Protocol != null && { protocol: input.Protocol }),
-        ...(input.SenderControlPort != null && { senderControlPort: input.SenderControlPort }),
-        ...(input.SenderIpAddress != null && { senderIpAddress: input.SenderIpAddress }),
-        ...(input.SourceListenerAddress != null && { sourceListenerAddress: input.SourceListenerAddress }),
-        ...(input.SourceListenerPort != null && { sourceListenerPort: input.SourceListenerPort }),
-        ...(input.StreamId != null && { streamId: input.StreamId }),
-        ...(input.VpcInterfaceName != null && { vpcInterfaceName: input.VpcInterfaceName }),
-        ...(input.WhitelistCidr != null && { whitelistCidr: input.WhitelistCidr }),
-    };
+    return take(input, {
+        decryption: [, (_) => se_Encryption(_, context), `Decryption`],
+        description: [, , `Description`],
+        entitlementArn: [, , `EntitlementArn`],
+        gatewayBridgeSource: [, (_) => se_SetGatewayBridgeSourceRequest(_, context), `GatewayBridgeSource`],
+        ingestPort: [, , `IngestPort`],
+        maxBitrate: [, , `MaxBitrate`],
+        maxLatency: [, , `MaxLatency`],
+        maxSyncBuffer: [, , `MaxSyncBuffer`],
+        mediaStreamSourceConfigurations: [
+            ,
+            (_) => se___listOfMediaStreamSourceConfigurationRequest(_, context),
+            `MediaStreamSourceConfigurations`,
+        ],
+        minLatency: [, , `MinLatency`],
+        name: [, , `Name`],
+        protocol: [, , `Protocol`],
+        senderControlPort: [, , `SenderControlPort`],
+        senderIpAddress: [, , `SenderIpAddress`],
+        sourceListenerAddress: [, , `SourceListenerAddress`],
+        sourceListenerPort: [, , `SourceListenerPort`],
+        streamId: [, , `StreamId`],
+        vpcInterfaceName: [, , `VpcInterfaceName`],
+        whitelistCidr: [, , `WhitelistCidr`],
+    });
 };
 const se_SourcePriority = (input, context) => {
-    return {
-        ...(input.PrimarySource != null && { primarySource: input.PrimarySource }),
-    };
+    return take(input, {
+        primarySource: [, , `PrimarySource`],
+    });
+};
+const se_UpdateBridgeFlowSourceRequest = (input, context) => {
+    return take(input, {
+        flowArn: [, , `FlowArn`],
+        flowVpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `FlowVpcInterfaceAttachment`],
+    });
+};
+const se_UpdateBridgeNetworkOutputRequest = (input, context) => {
+    return take(input, {
+        ipAddress: [, , `IpAddress`],
+        networkName: [, , `NetworkName`],
+        port: [, , `Port`],
+        protocol: [, , `Protocol`],
+        ttl: [, , `Ttl`],
+    });
+};
+const se_UpdateBridgeNetworkSourceRequest = (input, context) => {
+    return take(input, {
+        multicastIp: [, , `MulticastIp`],
+        networkName: [, , `NetworkName`],
+        port: [, , `Port`],
+        protocol: [, , `Protocol`],
+    });
+};
+const se_UpdateEgressGatewayBridgeRequest = (input, context) => {
+    return take(input, {
+        maxBitrate: [, , `MaxBitrate`],
+    });
 };
 const se_UpdateEncryption = (input, context) => {
-    return {
-        ...(input.Algorithm != null && { algorithm: input.Algorithm }),
-        ...(input.ConstantInitializationVector != null && {
-            constantInitializationVector: input.ConstantInitializationVector,
-        }),
-        ...(input.DeviceId != null && { deviceId: input.DeviceId }),
-        ...(input.KeyType != null && { keyType: input.KeyType }),
-        ...(input.Region != null && { region: input.Region }),
-        ...(input.ResourceId != null && { resourceId: input.ResourceId }),
-        ...(input.RoleArn != null && { roleArn: input.RoleArn }),
-        ...(input.SecretArn != null && { secretArn: input.SecretArn }),
-        ...(input.Url != null && { url: input.Url }),
-    };
+    return take(input, {
+        algorithm: [, , `Algorithm`],
+        constantInitializationVector: [, , `ConstantInitializationVector`],
+        deviceId: [, , `DeviceId`],
+        keyType: [, , `KeyType`],
+        region: [, , `Region`],
+        resourceId: [, , `ResourceId`],
+        roleArn: [, , `RoleArn`],
+        secretArn: [, , `SecretArn`],
+        url: [, , `Url`],
+    });
 };
 const se_UpdateFailoverConfig = (input, context) => {
-    return {
-        ...(input.FailoverMode != null && { failoverMode: input.FailoverMode }),
-        ...(input.RecoveryWindow != null && { recoveryWindow: input.RecoveryWindow }),
-        ...(input.SourcePriority != null && { sourcePriority: se_SourcePriority(input.SourcePriority, context) }),
-        ...(input.State != null && { state: input.State }),
-    };
+    return take(input, {
+        failoverMode: [, , `FailoverMode`],
+        recoveryWindow: [, , `RecoveryWindow`],
+        sourcePriority: [, (_) => se_SourcePriority(_, context), `SourcePriority`],
+        state: [, , `State`],
+    });
+};
+const se_UpdateGatewayBridgeSourceRequest = (input, context) => {
+    return take(input, {
+        bridgeArn: [, , `BridgeArn`],
+        vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
+    });
+};
+const se_UpdateIngressGatewayBridgeRequest = (input, context) => {
+    return take(input, {
+        maxBitrate: [, , `MaxBitrate`],
+        maxOutputs: [, , `MaxOutputs`],
+    });
 };
 const se_UpdateMaintenance = (input, context) => {
-    return {
-        ...(input.MaintenanceDay != null && { maintenanceDay: input.MaintenanceDay }),
-        ...(input.MaintenanceScheduledDate != null && { maintenanceScheduledDate: input.MaintenanceScheduledDate }),
-        ...(input.MaintenanceStartHour != null && { maintenanceStartHour: input.MaintenanceStartHour }),
-    };
+    return take(input, {
+        maintenanceDay: [, , `MaintenanceDay`],
+        maintenanceScheduledDate: [, , `MaintenanceScheduledDate`],
+        maintenanceStartHour: [, , `MaintenanceStartHour`],
+    });
 };
 const se_VpcInterfaceAttachment = (input, context) => {
-    return {
-        ...(input.VpcInterfaceName != null && { vpcInterfaceName: input.VpcInterfaceName }),
-    };
+    return take(input, {
+        vpcInterfaceName: [, , `VpcInterfaceName`],
+    });
 };
 const se_VpcInterfaceRequest = (input, context) => {
-    return {
-        ...(input.Name != null && { name: input.Name }),
-        ...(input.NetworkInterfaceType != null && { networkInterfaceType: input.NetworkInterfaceType }),
-        ...(input.RoleArn != null && { roleArn: input.RoleArn }),
-        ...(input.SecurityGroupIds != null && { securityGroupIds: se___listOf__string(input.SecurityGroupIds, context) }),
-        ...(input.SubnetId != null && { subnetId: input.SubnetId }),
-    };
+    return take(input, {
+        name: [, , `Name`],
+        networkInterfaceType: [, , `NetworkInterfaceType`],
+        roleArn: [, , `RoleArn`],
+        securityGroupIds: [, _json, `SecurityGroupIds`],
+        subnetId: [, , `SubnetId`],
+    });
 };
-const de___listOf__string = (output, context) => {
+const de___listOfBridgeOutput = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
-        return __expectString(entry);
+        return de_BridgeOutput(entry, context);
+    });
+    return retVal;
+};
+const de___listOfBridgeSource = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_BridgeSource(entry, context);
     });
     return retVal;
 };
@@ -2510,9 +4027,6 @@ const de___listOfDestinationConfiguration = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_DestinationConfiguration(entry, context);
     });
     return retVal;
@@ -2521,31 +4035,38 @@ const de___listOfEntitlement = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_Entitlement(entry, context);
     });
     return retVal;
 };
+const de___listOfGatewayNetwork = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_GatewayNetwork(entry, context);
+    });
+    return retVal;
+};
 const de___listOfInputConfiguration = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_InputConfiguration(entry, context);
     });
     return retVal;
 };
+const de___listOfListedBridge = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ListedBridge(entry, context);
+    });
+    return retVal;
+};
 const de___listOfListedEntitlement = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_ListedEntitlement(entry, context);
     });
     return retVal;
@@ -2554,20 +4075,30 @@ const de___listOfListedFlow = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_ListedFlow(entry, context);
     });
     return retVal;
 };
+const de___listOfListedGateway = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ListedGateway(entry, context);
+    });
+    return retVal;
+};
+const de___listOfListedGatewayInstance = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ListedGatewayInstance(entry, context);
+    });
+    return retVal;
+};
 const de___listOfMediaStream = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_MediaStream(entry, context);
     });
     return retVal;
@@ -2576,9 +4107,6 @@ const de___listOfMediaStreamOutputConfiguration = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_MediaStreamOutputConfiguration(entry, context);
     });
     return retVal;
@@ -2587,20 +4115,22 @@ const de___listOfMediaStreamSourceConfiguration = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_MediaStreamSourceConfiguration(entry, context);
     });
     return retVal;
 };
+const de___listOfMessageDetail = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_MessageDetail(entry, context);
+    });
+    return retVal;
+};
 const de___listOfOffering = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_Offering(entry, context);
     });
     return retVal;
@@ -2609,9 +4139,6 @@ const de___listOfOutput = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_Output(entry, context);
     });
     return retVal;
@@ -2620,9 +4147,6 @@ const de___listOfReservation = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_Reservation(entry, context);
     });
     return retVal;
@@ -2631,9 +4155,6 @@ const de___listOfSource = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_Source(entry, context);
     });
     return retVal;
@@ -2642,293 +4163,416 @@ const de___listOfVpcInterface = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return de_VpcInterface(entry, context);
     });
     return retVal;
 };
-const de___mapOf__string = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = __expectString(value);
-        return acc;
-    }, {});
+const de_Bridge = (output, context) => {
+    return take(output, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        BridgeMessages: (_) => [, de___listOfMessageDetail(_, context), `bridgeMessages`],
+        BridgeState: [, __expectString, `bridgeState`],
+        EgressGatewayBridge: (_) => [, de_EgressGatewayBridge(_, context), `egressGatewayBridge`],
+        IngressGatewayBridge: (_) => [, de_IngressGatewayBridge(_, context), `ingressGatewayBridge`],
+        Name: [, __expectString, `name`],
+        Outputs: (_) => [, de___listOfBridgeOutput(_, context), `outputs`],
+        PlacementArn: [, __expectString, `placementArn`],
+        SourceFailoverConfig: (_) => [, de_FailoverConfig(_, context), `sourceFailoverConfig`],
+        Sources: (_) => [, de___listOfBridgeSource(_, context), `sources`],
+    });
+};
+const de_BridgeFlowOutput = (output, context) => {
+    return take(output, {
+        FlowArn: [, __expectString, `flowArn`],
+        FlowSourceArn: [, __expectString, `flowSourceArn`],
+        Name: [, __expectString, `name`],
+    });
+};
+const de_BridgeFlowSource = (output, context) => {
+    return take(output, {
+        FlowArn: [, __expectString, `flowArn`],
+        FlowVpcInterfaceAttachment: (_) => [, de_VpcInterfaceAttachment(_, context), `flowVpcInterfaceAttachment`],
+        Name: [, __expectString, `name`],
+        OutputArn: [, __expectString, `outputArn`],
+    });
+};
+const de_BridgeNetworkOutput = (output, context) => {
+    return take(output, {
+        IpAddress: [, __expectString, `ipAddress`],
+        Name: [, __expectString, `name`],
+        NetworkName: [, __expectString, `networkName`],
+        Port: [, __expectInt32, `port`],
+        Protocol: [, __expectString, `protocol`],
+        Ttl: [, __expectInt32, `ttl`],
+    });
+};
+const de_BridgeNetworkSource = (output, context) => {
+    return take(output, {
+        MulticastIp: [, __expectString, `multicastIp`],
+        Name: [, __expectString, `name`],
+        NetworkName: [, __expectString, `networkName`],
+        Port: [, __expectInt32, `port`],
+        Protocol: [, __expectString, `protocol`],
+    });
+};
+const de_BridgeOutput = (output, context) => {
+    return take(output, {
+        FlowOutput: (_) => [, de_BridgeFlowOutput(_, context), `flowOutput`],
+        NetworkOutput: (_) => [, de_BridgeNetworkOutput(_, context), `networkOutput`],
+    });
+};
+const de_BridgeSource = (output, context) => {
+    return take(output, {
+        FlowSource: (_) => [, de_BridgeFlowSource(_, context), `flowSource`],
+        NetworkSource: (_) => [, de_BridgeNetworkSource(_, context), `networkSource`],
+    });
 };
 const de_DestinationConfiguration = (output, context) => {
-    return {
-        DestinationIp: __expectString(output.destinationIp),
-        DestinationPort: __expectInt32(output.destinationPort),
-        Interface: output.interface != null ? de_Interface(output.interface, context) : undefined,
-        OutboundIp: __expectString(output.outboundIp),
-    };
+    return take(output, {
+        DestinationIp: [, __expectString, `destinationIp`],
+        DestinationPort: [, __expectInt32, `destinationPort`],
+        Interface: (_) => [, de_Interface(_, context), `interface`],
+        OutboundIp: [, __expectString, `outboundIp`],
+    });
+};
+const de_EgressGatewayBridge = (output, context) => {
+    return take(output, {
+        InstanceId: [, __expectString, `instanceId`],
+        MaxBitrate: [, __expectInt32, `maxBitrate`],
+    });
 };
 const de_EncodingParameters = (output, context) => {
-    return {
-        CompressionFactor: __limitedParseDouble(output.compressionFactor),
-        EncoderProfile: __expectString(output.encoderProfile),
-    };
+    return take(output, {
+        CompressionFactor: [, __limitedParseDouble, `compressionFactor`],
+        EncoderProfile: [, __expectString, `encoderProfile`],
+    });
 };
 const de_Encryption = (output, context) => {
-    return {
-        Algorithm: __expectString(output.algorithm),
-        ConstantInitializationVector: __expectString(output.constantInitializationVector),
-        DeviceId: __expectString(output.deviceId),
-        KeyType: __expectString(output.keyType),
-        Region: __expectString(output.region),
-        ResourceId: __expectString(output.resourceId),
-        RoleArn: __expectString(output.roleArn),
-        SecretArn: __expectString(output.secretArn),
-        Url: __expectString(output.url),
-    };
+    return take(output, {
+        Algorithm: [, __expectString, `algorithm`],
+        ConstantInitializationVector: [, __expectString, `constantInitializationVector`],
+        DeviceId: [, __expectString, `deviceId`],
+        KeyType: [, __expectString, `keyType`],
+        Region: [, __expectString, `region`],
+        ResourceId: [, __expectString, `resourceId`],
+        RoleArn: [, __expectString, `roleArn`],
+        SecretArn: [, __expectString, `secretArn`],
+        Url: [, __expectString, `url`],
+    });
 };
 const de_Entitlement = (output, context) => {
-    return {
-        DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
-        Description: __expectString(output.description),
-        Encryption: output.encryption != null ? de_Encryption(output.encryption, context) : undefined,
-        EntitlementArn: __expectString(output.entitlementArn),
-        EntitlementStatus: __expectString(output.entitlementStatus),
-        Name: __expectString(output.name),
-        Subscribers: output.subscribers != null ? de___listOf__string(output.subscribers, context) : undefined,
-    };
+    return take(output, {
+        DataTransferSubscriberFeePercent: [, __expectInt32, `dataTransferSubscriberFeePercent`],
+        Description: [, __expectString, `description`],
+        Encryption: (_) => [, de_Encryption(_, context), `encryption`],
+        EntitlementArn: [, __expectString, `entitlementArn`],
+        EntitlementStatus: [, __expectString, `entitlementStatus`],
+        Name: [, __expectString, `name`],
+        Subscribers: [, _json, `subscribers`],
+    });
 };
 const de_FailoverConfig = (output, context) => {
-    return {
-        FailoverMode: __expectString(output.failoverMode),
-        RecoveryWindow: __expectInt32(output.recoveryWindow),
-        SourcePriority: output.sourcePriority != null ? de_SourcePriority(output.sourcePriority, context) : undefined,
-        State: __expectString(output.state),
-    };
+    return take(output, {
+        FailoverMode: [, __expectString, `failoverMode`],
+        RecoveryWindow: [, __expectInt32, `recoveryWindow`],
+        SourcePriority: (_) => [, de_SourcePriority(_, context), `sourcePriority`],
+        State: [, __expectString, `state`],
+    });
 };
 const de_Flow = (output, context) => {
-    return {
-        AvailabilityZone: __expectString(output.availabilityZone),
-        Description: __expectString(output.description),
-        EgressIp: __expectString(output.egressIp),
-        Entitlements: output.entitlements != null ? de___listOfEntitlement(output.entitlements, context) : undefined,
-        FlowArn: __expectString(output.flowArn),
-        Maintenance: output.maintenance != null ? de_Maintenance(output.maintenance, context) : undefined,
-        MediaStreams: output.mediaStreams != null ? de___listOfMediaStream(output.mediaStreams, context) : undefined,
-        Name: __expectString(output.name),
-        Outputs: output.outputs != null ? de___listOfOutput(output.outputs, context) : undefined,
-        Source: output.source != null ? de_Source(output.source, context) : undefined,
-        SourceFailoverConfig: output.sourceFailoverConfig != null ? de_FailoverConfig(output.sourceFailoverConfig, context) : undefined,
-        Sources: output.sources != null ? de___listOfSource(output.sources, context) : undefined,
-        Status: __expectString(output.status),
-        VpcInterfaces: output.vpcInterfaces != null ? de___listOfVpcInterface(output.vpcInterfaces, context) : undefined,
-    };
+    return take(output, {
+        AvailabilityZone: [, __expectString, `availabilityZone`],
+        Description: [, __expectString, `description`],
+        EgressIp: [, __expectString, `egressIp`],
+        Entitlements: (_) => [, de___listOfEntitlement(_, context), `entitlements`],
+        FlowArn: [, __expectString, `flowArn`],
+        Maintenance: (_) => [, de_Maintenance(_, context), `maintenance`],
+        MediaStreams: (_) => [, de___listOfMediaStream(_, context), `mediaStreams`],
+        Name: [, __expectString, `name`],
+        Outputs: (_) => [, de___listOfOutput(_, context), `outputs`],
+        Source: (_) => [, de_Source(_, context), `source`],
+        SourceFailoverConfig: (_) => [, de_FailoverConfig(_, context), `sourceFailoverConfig`],
+        Sources: (_) => [, de___listOfSource(_, context), `sources`],
+        Status: [, __expectString, `status`],
+        VpcInterfaces: (_) => [, de___listOfVpcInterface(_, context), `vpcInterfaces`],
+    });
 };
 const de_Fmtp = (output, context) => {
-    return {
-        ChannelOrder: __expectString(output.channelOrder),
-        Colorimetry: __expectString(output.colorimetry),
-        ExactFramerate: __expectString(output.exactFramerate),
-        Par: __expectString(output.par),
-        Range: __expectString(output.range),
-        ScanMode: __expectString(output.scanMode),
-        Tcs: __expectString(output.tcs),
-    };
+    return take(output, {
+        ChannelOrder: [, __expectString, `channelOrder`],
+        Colorimetry: [, __expectString, `colorimetry`],
+        ExactFramerate: [, __expectString, `exactFramerate`],
+        Par: [, __expectString, `par`],
+        Range: [, __expectString, `range`],
+        ScanMode: [, __expectString, `scanMode`],
+        Tcs: [, __expectString, `tcs`],
+    });
+};
+const de_Gateway = (output, context) => {
+    return take(output, {
+        EgressCidrBlocks: [, _json, `egressCidrBlocks`],
+        GatewayArn: [, __expectString, `gatewayArn`],
+        GatewayMessages: (_) => [, de___listOfMessageDetail(_, context), `gatewayMessages`],
+        GatewayState: [, __expectString, `gatewayState`],
+        Name: [, __expectString, `name`],
+        Networks: (_) => [, de___listOfGatewayNetwork(_, context), `networks`],
+    });
+};
+const de_GatewayBridgeSource = (output, context) => {
+    return take(output, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        VpcInterfaceAttachment: (_) => [, de_VpcInterfaceAttachment(_, context), `vpcInterfaceAttachment`],
+    });
+};
+const de_GatewayInstance = (output, context) => {
+    return take(output, {
+        BridgePlacement: [, __expectString, `bridgePlacement`],
+        ConnectionStatus: [, __expectString, `connectionStatus`],
+        GatewayArn: [, __expectString, `gatewayArn`],
+        GatewayInstanceArn: [, __expectString, `gatewayInstanceArn`],
+        InstanceId: [, __expectString, `instanceId`],
+        InstanceMessages: (_) => [, de___listOfMessageDetail(_, context), `instanceMessages`],
+        InstanceState: [, __expectString, `instanceState`],
+        RunningBridgeCount: [, __expectInt32, `runningBridgeCount`],
+    });
+};
+const de_GatewayNetwork = (output, context) => {
+    return take(output, {
+        CidrBlock: [, __expectString, `cidrBlock`],
+        Name: [, __expectString, `name`],
+    });
+};
+const de_IngressGatewayBridge = (output, context) => {
+    return take(output, {
+        InstanceId: [, __expectString, `instanceId`],
+        MaxBitrate: [, __expectInt32, `maxBitrate`],
+        MaxOutputs: [, __expectInt32, `maxOutputs`],
+    });
 };
 const de_InputConfiguration = (output, context) => {
-    return {
-        InputIp: __expectString(output.inputIp),
-        InputPort: __expectInt32(output.inputPort),
-        Interface: output.interface != null ? de_Interface(output.interface, context) : undefined,
-    };
+    return take(output, {
+        InputIp: [, __expectString, `inputIp`],
+        InputPort: [, __expectInt32, `inputPort`],
+        Interface: (_) => [, de_Interface(_, context), `interface`],
+    });
 };
 const de_Interface = (output, context) => {
-    return {
-        Name: __expectString(output.name),
-    };
+    return take(output, {
+        Name: [, __expectString, `name`],
+    });
+};
+const de_ListedBridge = (output, context) => {
+    return take(output, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        BridgeState: [, __expectString, `bridgeState`],
+        BridgeType: [, __expectString, `bridgeType`],
+        Name: [, __expectString, `name`],
+        PlacementArn: [, __expectString, `placementArn`],
+    });
 };
 const de_ListedEntitlement = (output, context) => {
-    return {
-        DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
-        EntitlementArn: __expectString(output.entitlementArn),
-        EntitlementName: __expectString(output.entitlementName),
-    };
+    return take(output, {
+        DataTransferSubscriberFeePercent: [, __expectInt32, `dataTransferSubscriberFeePercent`],
+        EntitlementArn: [, __expectString, `entitlementArn`],
+        EntitlementName: [, __expectString, `entitlementName`],
+    });
 };
 const de_ListedFlow = (output, context) => {
-    return {
-        AvailabilityZone: __expectString(output.availabilityZone),
-        Description: __expectString(output.description),
-        FlowArn: __expectString(output.flowArn),
-        Maintenance: output.maintenance != null ? de_Maintenance(output.maintenance, context) : undefined,
-        Name: __expectString(output.name),
-        SourceType: __expectString(output.sourceType),
-        Status: __expectString(output.status),
-    };
+    return take(output, {
+        AvailabilityZone: [, __expectString, `availabilityZone`],
+        Description: [, __expectString, `description`],
+        FlowArn: [, __expectString, `flowArn`],
+        Maintenance: (_) => [, de_Maintenance(_, context), `maintenance`],
+        Name: [, __expectString, `name`],
+        SourceType: [, __expectString, `sourceType`],
+        Status: [, __expectString, `status`],
+    });
+};
+const de_ListedGateway = (output, context) => {
+    return take(output, {
+        GatewayArn: [, __expectString, `gatewayArn`],
+        GatewayState: [, __expectString, `gatewayState`],
+        Name: [, __expectString, `name`],
+    });
+};
+const de_ListedGatewayInstance = (output, context) => {
+    return take(output, {
+        GatewayArn: [, __expectString, `gatewayArn`],
+        GatewayInstanceArn: [, __expectString, `gatewayInstanceArn`],
+        InstanceId: [, __expectString, `instanceId`],
+        InstanceState: [, __expectString, `instanceState`],
+    });
 };
 const de_Maintenance = (output, context) => {
-    return {
-        MaintenanceDay: __expectString(output.maintenanceDay),
-        MaintenanceDeadline: __expectString(output.maintenanceDeadline),
-        MaintenanceScheduledDate: __expectString(output.maintenanceScheduledDate),
-        MaintenanceStartHour: __expectString(output.maintenanceStartHour),
-    };
+    return take(output, {
+        MaintenanceDay: [, __expectString, `maintenanceDay`],
+        MaintenanceDeadline: [, __expectString, `maintenanceDeadline`],
+        MaintenanceScheduledDate: [, __expectString, `maintenanceScheduledDate`],
+        MaintenanceStartHour: [, __expectString, `maintenanceStartHour`],
+    });
 };
 const de_MediaStream = (output, context) => {
-    return {
-        Attributes: output.attributes != null ? de_MediaStreamAttributes(output.attributes, context) : undefined,
-        ClockRate: __expectInt32(output.clockRate),
-        Description: __expectString(output.description),
-        Fmt: __expectInt32(output.fmt),
-        MediaStreamId: __expectInt32(output.mediaStreamId),
-        MediaStreamName: __expectString(output.mediaStreamName),
-        MediaStreamType: __expectString(output.mediaStreamType),
-        VideoFormat: __expectString(output.videoFormat),
-    };
+    return take(output, {
+        Attributes: (_) => [, de_MediaStreamAttributes(_, context), `attributes`],
+        ClockRate: [, __expectInt32, `clockRate`],
+        Description: [, __expectString, `description`],
+        Fmt: [, __expectInt32, `fmt`],
+        MediaStreamId: [, __expectInt32, `mediaStreamId`],
+        MediaStreamName: [, __expectString, `mediaStreamName`],
+        MediaStreamType: [, __expectString, `mediaStreamType`],
+        VideoFormat: [, __expectString, `videoFormat`],
+    });
 };
 const de_MediaStreamAttributes = (output, context) => {
-    return {
-        Fmtp: output.fmtp != null ? de_Fmtp(output.fmtp, context) : undefined,
-        Lang: __expectString(output.lang),
-    };
+    return take(output, {
+        Fmtp: (_) => [, de_Fmtp(_, context), `fmtp`],
+        Lang: [, __expectString, `lang`],
+    });
 };
 const de_MediaStreamOutputConfiguration = (output, context) => {
-    return {
-        DestinationConfigurations: output.destinationConfigurations != null
-            ? de___listOfDestinationConfiguration(output.destinationConfigurations, context)
-            : undefined,
-        EncodingName: __expectString(output.encodingName),
-        EncodingParameters: output.encodingParameters != null ? de_EncodingParameters(output.encodingParameters, context) : undefined,
-        MediaStreamName: __expectString(output.mediaStreamName),
-    };
+    return take(output, {
+        DestinationConfigurations: (_) => [, de___listOfDestinationConfiguration(_, context), `destinationConfigurations`],
+        EncodingName: [, __expectString, `encodingName`],
+        EncodingParameters: (_) => [, de_EncodingParameters(_, context), `encodingParameters`],
+        MediaStreamName: [, __expectString, `mediaStreamName`],
+    });
 };
 const de_MediaStreamSourceConfiguration = (output, context) => {
-    return {
-        EncodingName: __expectString(output.encodingName),
-        InputConfigurations: output.inputConfigurations != null
-            ? de___listOfInputConfiguration(output.inputConfigurations, context)
-            : undefined,
-        MediaStreamName: __expectString(output.mediaStreamName),
-    };
+    return take(output, {
+        EncodingName: [, __expectString, `encodingName`],
+        InputConfigurations: (_) => [, de___listOfInputConfiguration(_, context), `inputConfigurations`],
+        MediaStreamName: [, __expectString, `mediaStreamName`],
+    });
+};
+const de_MessageDetail = (output, context) => {
+    return take(output, {
+        Code: [, __expectString, `code`],
+        Message: [, __expectString, `message`],
+        ResourceName: [, __expectString, `resourceName`],
+    });
 };
 const de_Messages = (output, context) => {
-    return {
-        Errors: output.errors != null ? de___listOf__string(output.errors, context) : undefined,
-    };
+    return take(output, {
+        Errors: [, _json, `errors`],
+    });
 };
 const de_Offering = (output, context) => {
-    return {
-        CurrencyCode: __expectString(output.currencyCode),
-        Duration: __expectInt32(output.duration),
-        DurationUnits: __expectString(output.durationUnits),
-        OfferingArn: __expectString(output.offeringArn),
-        OfferingDescription: __expectString(output.offeringDescription),
-        PricePerUnit: __expectString(output.pricePerUnit),
-        PriceUnits: __expectString(output.priceUnits),
-        ResourceSpecification: output.resourceSpecification != null
-            ? de_ResourceSpecification(output.resourceSpecification, context)
-            : undefined,
-    };
+    return take(output, {
+        CurrencyCode: [, __expectString, `currencyCode`],
+        Duration: [, __expectInt32, `duration`],
+        DurationUnits: [, __expectString, `durationUnits`],
+        OfferingArn: [, __expectString, `offeringArn`],
+        OfferingDescription: [, __expectString, `offeringDescription`],
+        PricePerUnit: [, __expectString, `pricePerUnit`],
+        PriceUnits: [, __expectString, `priceUnits`],
+        ResourceSpecification: (_) => [, de_ResourceSpecification(_, context), `resourceSpecification`],
+    });
 };
 const de_Output = (output, context) => {
-    return {
-        DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
-        Description: __expectString(output.description),
-        Destination: __expectString(output.destination),
-        Encryption: output.encryption != null ? de_Encryption(output.encryption, context) : undefined,
-        EntitlementArn: __expectString(output.entitlementArn),
-        ListenerAddress: __expectString(output.listenerAddress),
-        MediaLiveInputArn: __expectString(output.mediaLiveInputArn),
-        MediaStreamOutputConfigurations: output.mediaStreamOutputConfigurations != null
-            ? de___listOfMediaStreamOutputConfiguration(output.mediaStreamOutputConfigurations, context)
-            : undefined,
-        Name: __expectString(output.name),
-        OutputArn: __expectString(output.outputArn),
-        Port: __expectInt32(output.port),
-        Transport: output.transport != null ? de_Transport(output.transport, context) : undefined,
-        VpcInterfaceAttachment: output.vpcInterfaceAttachment != null
-            ? de_VpcInterfaceAttachment(output.vpcInterfaceAttachment, context)
-            : undefined,
-    };
+    return take(output, {
+        BridgeArn: [, __expectString, `bridgeArn`],
+        BridgePorts: [, _json, `bridgePorts`],
+        DataTransferSubscriberFeePercent: [, __expectInt32, `dataTransferSubscriberFeePercent`],
+        Description: [, __expectString, `description`],
+        Destination: [, __expectString, `destination`],
+        Encryption: (_) => [, de_Encryption(_, context), `encryption`],
+        EntitlementArn: [, __expectString, `entitlementArn`],
+        ListenerAddress: [, __expectString, `listenerAddress`],
+        MediaLiveInputArn: [, __expectString, `mediaLiveInputArn`],
+        MediaStreamOutputConfigurations: (_) => [
+            ,
+            de___listOfMediaStreamOutputConfiguration(_, context),
+            `mediaStreamOutputConfigurations`,
+        ],
+        Name: [, __expectString, `name`],
+        OutputArn: [, __expectString, `outputArn`],
+        Port: [, __expectInt32, `port`],
+        Transport: (_) => [, de_Transport(_, context), `transport`],
+        VpcInterfaceAttachment: (_) => [, de_VpcInterfaceAttachment(_, context), `vpcInterfaceAttachment`],
+    });
 };
 const de_Reservation = (output, context) => {
-    return {
-        CurrencyCode: __expectString(output.currencyCode),
-        Duration: __expectInt32(output.duration),
-        DurationUnits: __expectString(output.durationUnits),
-        End: __expectString(output.end),
-        OfferingArn: __expectString(output.offeringArn),
-        OfferingDescription: __expectString(output.offeringDescription),
-        PricePerUnit: __expectString(output.pricePerUnit),
-        PriceUnits: __expectString(output.priceUnits),
-        ReservationArn: __expectString(output.reservationArn),
-        ReservationName: __expectString(output.reservationName),
-        ReservationState: __expectString(output.reservationState),
-        ResourceSpecification: output.resourceSpecification != null
-            ? de_ResourceSpecification(output.resourceSpecification, context)
-            : undefined,
-        Start: __expectString(output.start),
-    };
+    return take(output, {
+        CurrencyCode: [, __expectString, `currencyCode`],
+        Duration: [, __expectInt32, `duration`],
+        DurationUnits: [, __expectString, `durationUnits`],
+        End: [, __expectString, `end`],
+        OfferingArn: [, __expectString, `offeringArn`],
+        OfferingDescription: [, __expectString, `offeringDescription`],
+        PricePerUnit: [, __expectString, `pricePerUnit`],
+        PriceUnits: [, __expectString, `priceUnits`],
+        ReservationArn: [, __expectString, `reservationArn`],
+        ReservationName: [, __expectString, `reservationName`],
+        ReservationState: [, __expectString, `reservationState`],
+        ResourceSpecification: (_) => [, de_ResourceSpecification(_, context), `resourceSpecification`],
+        Start: [, __expectString, `start`],
+    });
 };
 const de_ResourceSpecification = (output, context) => {
-    return {
-        ReservedBitrate: __expectInt32(output.reservedBitrate),
-        ResourceType: __expectString(output.resourceType),
-    };
+    return take(output, {
+        ReservedBitrate: [, __expectInt32, `reservedBitrate`],
+        ResourceType: [, __expectString, `resourceType`],
+    });
 };
 const de_Source = (output, context) => {
-    return {
-        DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
-        Decryption: output.decryption != null ? de_Encryption(output.decryption, context) : undefined,
-        Description: __expectString(output.description),
-        EntitlementArn: __expectString(output.entitlementArn),
-        IngestIp: __expectString(output.ingestIp),
-        IngestPort: __expectInt32(output.ingestPort),
-        MediaStreamSourceConfigurations: output.mediaStreamSourceConfigurations != null
-            ? de___listOfMediaStreamSourceConfiguration(output.mediaStreamSourceConfigurations, context)
-            : undefined,
-        Name: __expectString(output.name),
-        SenderControlPort: __expectInt32(output.senderControlPort),
-        SenderIpAddress: __expectString(output.senderIpAddress),
-        SourceArn: __expectString(output.sourceArn),
-        Transport: output.transport != null ? de_Transport(output.transport, context) : undefined,
-        VpcInterfaceName: __expectString(output.vpcInterfaceName),
-        WhitelistCidr: __expectString(output.whitelistCidr),
-    };
+    return take(output, {
+        DataTransferSubscriberFeePercent: [, __expectInt32, `dataTransferSubscriberFeePercent`],
+        Decryption: (_) => [, de_Encryption(_, context), `decryption`],
+        Description: [, __expectString, `description`],
+        EntitlementArn: [, __expectString, `entitlementArn`],
+        GatewayBridgeSource: (_) => [, de_GatewayBridgeSource(_, context), `gatewayBridgeSource`],
+        IngestIp: [, __expectString, `ingestIp`],
+        IngestPort: [, __expectInt32, `ingestPort`],
+        MediaStreamSourceConfigurations: (_) => [
+            ,
+            de___listOfMediaStreamSourceConfiguration(_, context),
+            `mediaStreamSourceConfigurations`,
+        ],
+        Name: [, __expectString, `name`],
+        SenderControlPort: [, __expectInt32, `senderControlPort`],
+        SenderIpAddress: [, __expectString, `senderIpAddress`],
+        SourceArn: [, __expectString, `sourceArn`],
+        Transport: (_) => [, de_Transport(_, context), `transport`],
+        VpcInterfaceName: [, __expectString, `vpcInterfaceName`],
+        WhitelistCidr: [, __expectString, `whitelistCidr`],
+    });
 };
 const de_SourcePriority = (output, context) => {
-    return {
-        PrimarySource: __expectString(output.primarySource),
-    };
+    return take(output, {
+        PrimarySource: [, __expectString, `primarySource`],
+    });
 };
 const de_Transport = (output, context) => {
-    return {
-        CidrAllowList: output.cidrAllowList != null ? de___listOf__string(output.cidrAllowList, context) : undefined,
-        MaxBitrate: __expectInt32(output.maxBitrate),
-        MaxLatency: __expectInt32(output.maxLatency),
-        MaxSyncBuffer: __expectInt32(output.maxSyncBuffer),
-        MinLatency: __expectInt32(output.minLatency),
-        Protocol: __expectString(output.protocol),
-        RemoteId: __expectString(output.remoteId),
-        SenderControlPort: __expectInt32(output.senderControlPort),
-        SenderIpAddress: __expectString(output.senderIpAddress),
-        SmoothingLatency: __expectInt32(output.smoothingLatency),
-        SourceListenerAddress: __expectString(output.sourceListenerAddress),
-        SourceListenerPort: __expectInt32(output.sourceListenerPort),
-        StreamId: __expectString(output.streamId),
-    };
+    return take(output, {
+        CidrAllowList: [, _json, `cidrAllowList`],
+        MaxBitrate: [, __expectInt32, `maxBitrate`],
+        MaxLatency: [, __expectInt32, `maxLatency`],
+        MaxSyncBuffer: [, __expectInt32, `maxSyncBuffer`],
+        MinLatency: [, __expectInt32, `minLatency`],
+        Protocol: [, __expectString, `protocol`],
+        RemoteId: [, __expectString, `remoteId`],
+        SenderControlPort: [, __expectInt32, `senderControlPort`],
+        SenderIpAddress: [, __expectString, `senderIpAddress`],
+        SmoothingLatency: [, __expectInt32, `smoothingLatency`],
+        SourceListenerAddress: [, __expectString, `sourceListenerAddress`],
+        SourceListenerPort: [, __expectInt32, `sourceListenerPort`],
+        StreamId: [, __expectString, `streamId`],
+    });
 };
 const de_VpcInterface = (output, context) => {
-    return {
-        Name: __expectString(output.name),
-        NetworkInterfaceIds: output.networkInterfaceIds != null ? de___listOf__string(output.networkInterfaceIds, context) : undefined,
-        NetworkInterfaceType: __expectString(output.networkInterfaceType),
-        RoleArn: __expectString(output.roleArn),
-        SecurityGroupIds: output.securityGroupIds != null ? de___listOf__string(output.securityGroupIds, context) : undefined,
-        SubnetId: __expectString(output.subnetId),
-    };
+    return take(output, {
+        Name: [, __expectString, `name`],
+        NetworkInterfaceIds: [, _json, `networkInterfaceIds`],
+        NetworkInterfaceType: [, __expectString, `networkInterfaceType`],
+        RoleArn: [, __expectString, `roleArn`],
+        SecurityGroupIds: [, _json, `securityGroupIds`],
+        SubnetId: [, __expectString, `subnetId`],
+    });
 };
 const de_VpcInterfaceAttachment = (output, context) => {
-    return {
-        VpcInterfaceName: __expectString(output.vpcInterfaceName),
-    };
+    return take(output, {
+        VpcInterfaceName: [, __expectString, `vpcInterfaceName`],
+    });
 };
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,