@aws-sdk/client-mediaconnect 3.310.0 → 3.313.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 { 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({
+        ...(input.Outputs != null && { outputs: se___listOfAddBridgeOutputRequest(input.Outputs, context) }),
+    });
+    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({
+        ...(input.Sources != null && { sources: se___listOfAddBridgeSourceRequest(input.Sources, context) }),
+    });
+    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 = {
@@ -86,6 +128,38 @@ export const se_AddFlowVpcInterfacesCommand = async (input, context) => {
         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({
+        ...(input.EgressGatewayBridge != null && {
+            egressGatewayBridge: se_AddEgressGatewayBridgeRequest(input.EgressGatewayBridge, context),
+        }),
+        ...(input.IngressGatewayBridge != null && {
+            ingressGatewayBridge: se_AddIngressGatewayBridgeRequest(input.IngressGatewayBridge, context),
+        }),
+        ...(input.Name != null && { name: input.Name }),
+        ...(input.Outputs != null && { outputs: se___listOfAddBridgeOutputRequest(input.Outputs, context) }),
+        ...(input.PlacementArn != null && { placementArn: input.PlacementArn }),
+        ...(input.SourceFailoverConfig != null && {
+            sourceFailoverConfig: se_FailoverConfig(input.SourceFailoverConfig, context),
+        }),
+        ...(input.Sources != null && { sources: se___listOfAddBridgeSourceRequest(input.Sources, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_CreateFlowCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -119,6 +193,44 @@ export const se_CreateFlowCommand = async (input, context) => {
         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({
+        ...(input.EgressCidrBlocks != null && { egressCidrBlocks: se___listOf__string(input.EgressCidrBlocks, context) }),
+        ...(input.Name != null && { name: input.Name }),
+        ...(input.Networks != null && { networks: se___listOfGatewayNetwork(input.Networks, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        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 +247,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 +316,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 = {};
@@ -206,6 +404,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 +465,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 = {};
@@ -324,6 +584,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 = {};
@@ -488,16 +784,21 @@ 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.EgressGatewayBridge != null && {
+            egressGatewayBridge: se_UpdateEgressGatewayBridgeRequest(input.EgressGatewayBridge, context),
+        }),
+        ...(input.IngressGatewayBridge != null && {
+            ingressGatewayBridge: se_UpdateIngressGatewayBridgeRequest(input.IngressGatewayBridge, context),
+        }),
         ...(input.SourceFailoverConfig != null && {
             sourceFailoverConfig: se_UpdateFailoverConfig(input.SourceFailoverConfig, context),
         }),
@@ -512,21 +813,20 @@ 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) }),
+        ...(input.NetworkOutput != null && {
+            networkOutput: se_UpdateBridgeNetworkOutputRequest(input.NetworkOutput, context),
+        }),
     });
     return new __HttpRequest({
         protocol,
@@ -538,7 +838,104 @@ 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/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.FlowSource != null && { flowSource: se_UpdateBridgeFlowSourceRequest(input.FlowSource, context) }),
+        ...(input.NetworkSource != null && {
+            networkSource: se_UpdateBridgeNetworkSourceRequest(input.NetworkSource, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+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/bridges/{BridgeArn}/state";
+    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.DesiredState != null && { desiredState: input.DesiredState }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+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}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.Maintenance != null && { maintenance: se_UpdateMaintenance(input.Maintenance, context) }),
+        ...(input.SourceFailoverConfig != null && {
+            sourceFailoverConfig: se_UpdateFailoverConfig(input.SourceFailoverConfig, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+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({
+        ...(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) }),
+    });
+    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",
@@ -618,6 +1015,9 @@ export const se_UpdateFlowSourceCommand = async (input, context) => {
         ...(input.Decryption != null && { decryption: se_UpdateEncryption(input.Decryption, context) }),
         ...(input.Description != null && { description: input.Description }),
         ...(input.EntitlementArn != null && { entitlementArn: input.EntitlementArn }),
+        ...(input.GatewayBridgeSource != null && {
+            gatewayBridgeSource: se_UpdateGatewayBridgeSourceRequest(input.GatewayBridgeSource, context),
+        }),
         ...(input.IngestPort != null && { ingestPort: input.IngestPort }),
         ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
         ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
@@ -645,23 +1045,714 @@ 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_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({
+        ...(input.BridgePlacement != null && { bridgePlacement: input.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.bridgeArn != null) {
+        contents.BridgeArn = __expectString(data.bridgeArn);
+    }
+    if (data.outputs != null) {
+        contents.Outputs = de___listOfBridgeOutput(data.outputs, context);
+    }
+    return contents;
+};
+const de_AddBridgeOutputsCommandError = 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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+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.bridgeArn != null) {
+        contents.BridgeArn = __expectString(data.bridgeArn);
+    }
+    if (data.sources != null) {
+        contents.Sources = de___listOfBridgeSource(data.sources, context);
+    }
+    return contents;
+};
+const de_AddBridgeSourcesCommandError = 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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const de_AddFlowMediaStreamsCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        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.mediaStreams != null) {
+        contents.MediaStreams = de___listOfMediaStream(data.mediaStreams, context);
+    }
+    return contents;
+};
+const de_AddFlowMediaStreamsCommandError = 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;
+            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);
+    }
+    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);
+    }
+    return contents;
+};
+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);
+        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({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const de_AddFlowSourcesCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_AddFlowSourcesCommandError(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);
+    }
+    return contents;
+};
+const de_AddFlowSourcesCommandError = 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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+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.vpcInterfaces != null) {
+        contents.VpcInterfaces = de___listOfVpcInterface(data.vpcInterfaces, context);
+    }
+    return contents;
+};
+const de_AddFlowVpcInterfacesCommandError = 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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+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.bridge != null) {
+        contents.Bridge = de_Bridge(data.bridge, context);
+    }
+    return contents;
+};
+const de_CreateBridgeCommandError = 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 "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 "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({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+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.flow != null) {
+        contents.Flow = de_Flow(data.flow, context);
+    }
+    return contents;
+};
+const de_CreateFlowCommandError = 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 "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 "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({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+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.gateway != null) {
+        contents.Gateway = de_Gateway(data.gateway, context);
+    }
+    return contents;
+};
+const de_CreateGatewayCommandError = 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 "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 "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({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const de_DeleteBridgeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteBridgeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.bridgeArn != null) {
+        contents.BridgeArn = __expectString(data.bridgeArn);
+    }
+    return contents;
+};
+const de_DeleteBridgeCommandError = 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;
+            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);
+    }
+    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);
+    }
+    return contents;
+};
+const de_DeleteFlowCommandError = 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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const de_DeleteGatewayCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteGatewayCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.gatewayArn != null) {
+        contents.GatewayArn = __expectString(data.gatewayArn);
+    }
+    return contents;
+};
+const de_DeleteGatewayCommandError = 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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+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.gatewayInstanceArn != null) {
+        contents.GatewayInstanceArn = __expectString(data.gatewayInstanceArn);
+    }
+    if (data.instanceState != null) {
+        contents.InstanceState = __expectString(data.instanceState);
+    }
+    return contents;
+};
+const de_DeregisterGatewayInstanceCommandError = 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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const de_DescribeBridgeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeBridgeCommandError(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);
+    if (data.bridge != null) {
+        contents.Bridge = de_Bridge(data.bridge, context);
     }
     return contents;
 };
-const de_AddFlowMediaStreamsCommandError = async (output, context) => {
+const de_DescribeBridgeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -671,6 +1762,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);
@@ -696,32 +1790,29 @@ const de_AddFlowMediaStreamsCommandError = async (output, context) => {
             });
     }
 };
-export const de_AddFlowOutputsCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_AddFlowOutputsCommandError(output, context);
+export const de_DescribeFlowCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeFlowCommandError(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.flow != null) {
+        contents.Flow = de_Flow(data.flow, context);
     }
-    if (data.outputs != null) {
-        contents.Outputs = de___listOfOutput(data.outputs, context);
+    if (data.messages != null) {
+        contents.Messages = de_Messages(data.messages, context);
     }
     return contents;
 };
-const de_AddFlowOutputsCommandError = async (output, context) => {
+const de_DescribeFlowCommandError = 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);
@@ -750,23 +1841,20 @@ const de_AddFlowOutputsCommandError = async (output, context) => {
             });
     }
 };
-export const de_AddFlowSourcesCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_AddFlowSourcesCommandError(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.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
-    }
-    if (data.sources != null) {
-        contents.Sources = de___listOfSource(data.sources, context);
+    if (data.gateway != null) {
+        contents.Gateway = de_Gateway(data.gateway, context);
     }
     return contents;
 };
-const de_AddFlowSourcesCommandError = async (output, context) => {
+const de_DescribeGatewayCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -776,6 +1864,9 @@ const de_AddFlowSourcesCommandError = 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);
@@ -801,23 +1892,20 @@ const de_AddFlowSourcesCommandError = async (output, context) => {
             });
     }
 };
-export const de_AddFlowVpcInterfacesCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_AddFlowVpcInterfacesCommandError(output, context);
+export const de_DescribeGatewayInstanceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        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.vpcInterfaces != null) {
-        contents.VpcInterfaces = de___listOfVpcInterface(data.vpcInterfaces, context);
+    if (data.gatewayInstance != null) {
+        contents.GatewayInstance = de_GatewayInstance(data.gatewayInstance, context);
     }
     return contents;
 };
-const de_AddFlowVpcInterfacesCommandError = async (output, context) => {
+const de_DescribeGatewayInstanceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -827,6 +1915,9 @@ const de_AddFlowVpcInterfacesCommandError = 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);
@@ -852,20 +1943,20 @@ const de_AddFlowVpcInterfacesCommandError = async (output, context) => {
             });
     }
 };
-export const de_CreateFlowCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_CreateFlowCommandError(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.flow != null) {
-        contents.Flow = de_Flow(data.flow, context);
+    if (data.offering != null) {
+        contents.Offering = de_Offering(data.offering, context);
     }
     return contents;
 };
-const de_CreateFlowCommandError = async (output, context) => {
+const de_DescribeOfferingCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -875,15 +1966,12 @@ 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);
@@ -900,23 +1988,20 @@ const de_CreateFlowCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteFlowCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteFlowCommandError(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.status != null) {
-        contents.Status = __expectString(data.status);
+    if (data.reservation != null) {
+        contents.Reservation = de_Reservation(data.reservation, context);
     }
     return contents;
 };
-const de_DeleteFlowCommandError = async (output, context) => {
+const de_DescribeReservationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -926,9 +2011,6 @@ const de_DeleteFlowCommandError = 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);
@@ -951,23 +2033,23 @@ const de_DeleteFlowCommandError = async (output, context) => {
             });
     }
 };
-export const de_DescribeFlowCommand = async (output, context) => {
+export const de_GrantFlowEntitlementsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeFlowCommandError(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.flow != null) {
-        contents.Flow = de_Flow(data.flow, context);
+    if (data.entitlements != null) {
+        contents.Entitlements = de___listOfEntitlement(data.entitlements, context);
     }
-    if (data.messages != null) {
-        contents.Messages = de_Messages(data.messages, context);
+    if (data.flowArn != null) {
+        contents.FlowArn = __expectString(data.flowArn);
     }
     return contents;
 };
-const de_DescribeFlowCommandError = async (output, context) => {
+const de_GrantFlowEntitlementsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -980,6 +2062,9 @@ const de_DescribeFlowCommandError = 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);
@@ -1002,20 +2087,23 @@ const de_DescribeFlowCommandError = async (output, context) => {
             });
     }
 };
-export const de_DescribeOfferingCommand = async (output, context) => {
+export const de_ListBridgesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeOfferingCommandError(output, context);
+        return de_ListBridgesCommandError(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);
+    if (data.bridges != null) {
+        contents.Bridges = de___listOfListedBridge(data.bridges, context);
+    }
+    if (data.nextToken != null) {
+        contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const de_DescribeOfferingCommandError = async (output, context) => {
+const de_ListBridgesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1025,12 +2113,12 @@ const de_DescribeOfferingCommandError = 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);
@@ -1047,20 +2135,23 @@ const de_DescribeOfferingCommandError = async (output, context) => {
             });
     }
 };
-export const de_DescribeReservationCommand = async (output, context) => {
+export const de_ListEntitlementsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeReservationCommandError(output, context);
+        return de_ListEntitlementsCommandError(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);
+    if (data.entitlements != null) {
+        contents.Entitlements = de___listOfListedEntitlement(data.entitlements, context);
+    }
+    if (data.nextToken != null) {
+        contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const de_DescribeReservationCommandError = async (output, context) => {
+const de_ListEntitlementsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1073,9 +2164,6 @@ const de_DescribeReservationCommandError = async (output, 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);
@@ -1092,23 +2180,23 @@ const de_DescribeReservationCommandError = async (output, context) => {
             });
     }
 };
-export const de_GrantFlowEntitlementsCommand = async (output, context) => {
+export const de_ListFlowsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GrantFlowEntitlementsCommandError(output, context);
+        return de_ListFlowsCommandError(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.flows != null) {
+        contents.Flows = de___listOfListedFlow(data.flows, context);
     }
-    if (data.flowArn != null) {
-        contents.FlowArn = __expectString(data.flowArn);
+    if (data.nextToken != null) {
+        contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const de_GrantFlowEntitlementsCommandError = async (output, context) => {
+const de_ListFlowsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1118,18 +2206,9 @@ const de_GrantFlowEntitlementsCommandError = 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 "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);
-        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);
@@ -1146,23 +2225,23 @@ const de_GrantFlowEntitlementsCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListEntitlementsCommand = async (output, context) => {
+export const de_ListGatewayInstancesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListEntitlementsCommandError(output, context);
+        return de_ListGatewayInstancesCommandError(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.instances != null) {
+        contents.Instances = de___listOfListedGatewayInstance(data.instances, context);
     }
     if (data.nextToken != null) {
         contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const de_ListEntitlementsCommandError = async (output, context) => {
+const de_ListGatewayInstancesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1172,6 +2251,9 @@ const de_ListEntitlementsCommandError = 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);
@@ -1191,23 +2273,23 @@ const de_ListEntitlementsCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListFlowsCommand = async (output, context) => {
+export const de_ListGatewaysCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListFlowsCommandError(output, context);
+        return de_ListGatewaysCommandError(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.gateways != null) {
+        contents.Gateways = de___listOfListedGateway(data.gateways, context);
     }
     if (data.nextToken != null) {
         contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const de_ListFlowsCommandError = async (output, context) => {
+const de_ListGatewaysCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1217,6 +2299,9 @@ 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 "InternalServerErrorException":
         case "com.amazonaws.mediaconnect#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
@@ -1339,7 +2424,97 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
     }
     return contents;
 };
-const de_ListTagsForResourceCommandError = async (output, context) => {
+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;
+            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);
+    }
+    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);
+    }
+    return contents;
+};
+const de_PurchaseOfferingCommandError = 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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const de_RemoveBridgeOutputCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_RemoveBridgeOutputCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.bridgeArn != null) {
+        contents.BridgeArn = __expectString(data.bridgeArn);
+    }
+    if (data.outputName != null) {
+        contents.OutputName = __expectString(data.outputName);
+    }
+    return contents;
+};
+const de_RemoveBridgeOutputCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1349,12 +2524,24 @@ const de_ListTagsForResourceCommandError = 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);
+        case "TooManyRequestsException":
+        case "com.amazonaws.mediaconnect#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1365,20 +2552,23 @@ const de_ListTagsForResourceCommandError = async (output, context) => {
             });
     }
 };
-export const de_PurchaseOfferingCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_PurchaseOfferingCommandError(output, context);
+export const de_RemoveBridgeSourceCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_RemoveBridgeSourceCommandError(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);
+    if (data.bridgeArn != null) {
+        contents.BridgeArn = __expectString(data.bridgeArn);
+    }
+    if (data.sourceName != null) {
+        contents.SourceName = __expectString(data.sourceName);
     }
     return contents;
 };
-const de_PurchaseOfferingCommandError = async (output, context) => {
+const de_RemoveBridgeSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1388,6 +2578,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);
@@ -1845,6 +3038,219 @@ const de_UntagResourceCommandError = async (output, context) => {
             });
     }
 };
+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");
+    if (data.bridge != null) {
+        contents.Bridge = de_Bridge(data.bridge, context);
+    }
+    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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                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");
+    if (data.bridgeArn != null) {
+        contents.BridgeArn = __expectString(data.bridgeArn);
+    }
+    if (data.output != null) {
+        contents.Output = de_BridgeOutput(data.output, context);
+    }
+    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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                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");
+    if (data.bridgeArn != null) {
+        contents.BridgeArn = __expectString(data.bridgeArn);
+    }
+    if (data.source != null) {
+        contents.Source = de_BridgeSource(data.source, context);
+    }
+    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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                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");
+    if (data.bridgeArn != null) {
+        contents.BridgeArn = __expectString(data.bridgeArn);
+    }
+    if (data.desiredState != null) {
+        contents.DesiredState = __expectString(data.desiredState);
+    }
+    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;
+            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);
@@ -2097,26 +3503,104 @@ const de_UpdateFlowSourceCommandError = async (output, context) => {
             });
     }
 };
-const map = __map;
-const de_AddFlowOutputs420ExceptionRes = async (parsedOutput, context) => {
+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");
+    if (data.bridgePlacement != null) {
+        contents.BridgePlacement = __expectString(data.bridgePlacement);
+    }
+    if (data.gatewayInstanceArn != null) {
+        contents.GatewayInstanceArn = __expectString(data.gatewayInstanceArn);
+    }
+    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;
+            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);
+    }
+    const exception = new AddFlowOutputs420Exception({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.Message = __expectString(data.message);
+    }
+    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;
     if (data.message != null) {
         contents.Message = __expectString(data.message);
     }
-    const exception = new AddFlowOutputs420Exception({
+    const exception = new ConflictException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_BadRequestExceptionRes = async (parsedOutput, context) => {
+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 exception = new CreateBridge420Exception({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
     });
@@ -2134,6 +3618,18 @@ const de_CreateFlow420ExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_CreateGateway420ExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.Message = __expectString(data.message);
+    }
+    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;
@@ -2213,6 +3709,20 @@ const se___listOf__string = (input, context) => {
         return entry;
     });
 };
+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 se_AddBridgeSourceRequest(entry, context);
+    });
+};
 const se___listOfAddMediaStreamRequest = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -2234,6 +3744,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)
@@ -2285,6 +3802,60 @@ const se___mapOf__string = (input, context) => {
         return acc;
     }, {});
 };
+const se_AddBridgeFlowSourceRequest = (input, context) => {
+    return {
+        ...(input.FlowArn != null && { flowArn: input.FlowArn }),
+        ...(input.FlowVpcInterfaceAttachment != null && {
+            flowVpcInterfaceAttachment: se_VpcInterfaceAttachment(input.FlowVpcInterfaceAttachment, context),
+        }),
+        ...(input.Name != null && { name: input.Name }),
+    };
+};
+const se_AddBridgeNetworkOutputRequest = (input, context) => {
+    return {
+        ...(input.IpAddress != null && { ipAddress: input.IpAddress }),
+        ...(input.Name != null && { name: input.Name }),
+        ...(input.NetworkName != null && { networkName: input.NetworkName }),
+        ...(input.Port != null && { port: input.Port }),
+        ...(input.Protocol != null && { protocol: input.Protocol }),
+        ...(input.Ttl != null && { ttl: input.Ttl }),
+    };
+};
+const se_AddBridgeNetworkSourceRequest = (input, context) => {
+    return {
+        ...(input.MulticastIp != null && { multicastIp: input.MulticastIp }),
+        ...(input.Name != null && { name: input.Name }),
+        ...(input.NetworkName != null && { networkName: input.NetworkName }),
+        ...(input.Port != null && { port: input.Port }),
+        ...(input.Protocol != null && { protocol: input.Protocol }),
+    };
+};
+const se_AddBridgeOutputRequest = (input, context) => {
+    return {
+        ...(input.NetworkOutput != null && {
+            networkOutput: se_AddBridgeNetworkOutputRequest(input.NetworkOutput, context),
+        }),
+    };
+};
+const se_AddBridgeSourceRequest = (input, context) => {
+    return {
+        ...(input.FlowSource != null && { flowSource: se_AddBridgeFlowSourceRequest(input.FlowSource, context) }),
+        ...(input.NetworkSource != null && {
+            networkSource: se_AddBridgeNetworkSourceRequest(input.NetworkSource, context),
+        }),
+    };
+};
+const se_AddEgressGatewayBridgeRequest = (input, context) => {
+    return {
+        ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
+    };
+};
+const se_AddIngressGatewayBridgeRequest = (input, context) => {
+    return {
+        ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
+        ...(input.MaxOutputs != null && { maxOutputs: input.MaxOutputs }),
+    };
+};
 const se_AddMaintenance = (input, context) => {
     return {
         ...(input.MaintenanceDay != null && { maintenanceDay: input.MaintenanceDay }),
@@ -2372,6 +3943,12 @@ const se_FmtpRequest = (input, context) => {
         ...(input.Tcs != null && { tcs: input.Tcs }),
     };
 };
+const se_GatewayNetwork = (input, context) => {
+    return {
+        ...(input.CidrBlock != null && { cidrBlock: input.CidrBlock }),
+        ...(input.Name != null && { name: input.Name }),
+    };
+};
 const se_GrantEntitlementRequest = (input, context) => {
     return {
         ...(input.DataTransferSubscriberFeePercent != null && {
@@ -2422,11 +3999,22 @@ const se_MediaStreamSourceConfigurationRequest = (input, context) => {
         ...(input.MediaStreamName != null && { mediaStreamName: input.MediaStreamName }),
     };
 };
+const se_SetGatewayBridgeSourceRequest = (input, context) => {
+    return {
+        ...(input.BridgeArn != null && { bridgeArn: input.BridgeArn }),
+        ...(input.VpcInterfaceAttachment != null && {
+            vpcInterfaceAttachment: se_VpcInterfaceAttachment(input.VpcInterfaceAttachment, context),
+        }),
+    };
+};
 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.GatewayBridgeSource != null && {
+            gatewayBridgeSource: se_SetGatewayBridgeSourceRequest(input.GatewayBridgeSource, context),
+        }),
         ...(input.IngestPort != null && { ingestPort: input.IngestPort }),
         ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
         ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
@@ -2451,6 +4039,36 @@ const se_SourcePriority = (input, context) => {
         ...(input.PrimarySource != null && { primarySource: input.PrimarySource }),
     };
 };
+const se_UpdateBridgeFlowSourceRequest = (input, context) => {
+    return {
+        ...(input.FlowArn != null && { flowArn: input.FlowArn }),
+        ...(input.FlowVpcInterfaceAttachment != null && {
+            flowVpcInterfaceAttachment: se_VpcInterfaceAttachment(input.FlowVpcInterfaceAttachment, context),
+        }),
+    };
+};
+const se_UpdateBridgeNetworkOutputRequest = (input, context) => {
+    return {
+        ...(input.IpAddress != null && { ipAddress: input.IpAddress }),
+        ...(input.NetworkName != null && { networkName: input.NetworkName }),
+        ...(input.Port != null && { port: input.Port }),
+        ...(input.Protocol != null && { protocol: input.Protocol }),
+        ...(input.Ttl != null && { ttl: input.Ttl }),
+    };
+};
+const se_UpdateBridgeNetworkSourceRequest = (input, context) => {
+    return {
+        ...(input.MulticastIp != null && { multicastIp: input.MulticastIp }),
+        ...(input.NetworkName != null && { networkName: input.NetworkName }),
+        ...(input.Port != null && { port: input.Port }),
+        ...(input.Protocol != null && { protocol: input.Protocol }),
+    };
+};
+const se_UpdateEgressGatewayBridgeRequest = (input, context) => {
+    return {
+        ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
+    };
+};
 const se_UpdateEncryption = (input, context) => {
     return {
         ...(input.Algorithm != null && { algorithm: input.Algorithm }),
@@ -2474,6 +4092,20 @@ const se_UpdateFailoverConfig = (input, context) => {
         ...(input.State != null && { state: input.State }),
     };
 };
+const se_UpdateGatewayBridgeSourceRequest = (input, context) => {
+    return {
+        ...(input.BridgeArn != null && { bridgeArn: input.BridgeArn }),
+        ...(input.VpcInterfaceAttachment != null && {
+            vpcInterfaceAttachment: se_VpcInterfaceAttachment(input.VpcInterfaceAttachment, context),
+        }),
+    };
+};
+const se_UpdateIngressGatewayBridgeRequest = (input, context) => {
+    return {
+        ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
+        ...(input.MaxOutputs != null && { maxOutputs: input.MaxOutputs }),
+    };
+};
 const se_UpdateMaintenance = (input, context) => {
     return {
         ...(input.MaintenanceDay != null && { maintenanceDay: input.MaintenanceDay }),
@@ -2495,6 +4127,17 @@ const se_VpcInterfaceRequest = (input, context) => {
         ...(input.SubnetId != null && { subnetId: input.SubnetId }),
     };
 };
+const de___listOf__integer = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectInt32(entry);
+    });
+    return retVal;
+};
 const de___listOf__string = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -2506,6 +4149,28 @@ const de___listOf__string = (output, context) => {
     });
     return retVal;
 };
+const de___listOfBridgeOutput = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return de_BridgeOutput(entry, context);
+    });
+    return retVal;
+};
+const de___listOfBridgeSource = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return de_BridgeSource(entry, context);
+    });
+    return retVal;
+};
 const de___listOfDestinationConfiguration = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -2528,6 +4193,17 @@ const de___listOfEntitlement = (output, context) => {
     });
     return retVal;
 };
+const de___listOfGatewayNetwork = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return de_GatewayNetwork(entry, context);
+    });
+    return retVal;
+};
 const de___listOfInputConfiguration = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -2539,6 +4215,17 @@ const de___listOfInputConfiguration = (output, context) => {
     });
     return retVal;
 };
+const de___listOfListedBridge = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return de_ListedBridge(entry, context);
+    });
+    return retVal;
+};
 const de___listOfListedEntitlement = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -2561,6 +4248,28 @@ const de___listOfListedFlow = (output, context) => {
     });
     return retVal;
 };
+const de___listOfListedGateway = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return de_ListedGateway(entry, context);
+    });
+    return retVal;
+};
+const de___listOfListedGatewayInstance = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return de_ListedGatewayInstance(entry, context);
+    });
+    return retVal;
+};
 const de___listOfMediaStream = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -2594,6 +4303,17 @@ const de___listOfMediaStreamSourceConfiguration = (output, context) => {
     });
     return retVal;
 };
+const de___listOfMessageDetail = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return de_MessageDetail(entry, context);
+    });
+    return retVal;
+};
 const de___listOfOffering = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -2658,6 +4378,68 @@ const de___mapOf__string = (output, context) => {
         return acc;
     }, {});
 };
+const de_Bridge = (output, context) => {
+    return {
+        BridgeArn: __expectString(output.bridgeArn),
+        BridgeMessages: output.bridgeMessages != null ? de___listOfMessageDetail(output.bridgeMessages, context) : undefined,
+        BridgeState: __expectString(output.bridgeState),
+        EgressGatewayBridge: output.egressGatewayBridge != null ? de_EgressGatewayBridge(output.egressGatewayBridge, context) : undefined,
+        IngressGatewayBridge: output.ingressGatewayBridge != null ? de_IngressGatewayBridge(output.ingressGatewayBridge, context) : undefined,
+        Name: __expectString(output.name),
+        Outputs: output.outputs != null ? de___listOfBridgeOutput(output.outputs, context) : undefined,
+        PlacementArn: __expectString(output.placementArn),
+        SourceFailoverConfig: output.sourceFailoverConfig != null ? de_FailoverConfig(output.sourceFailoverConfig, context) : undefined,
+        Sources: output.sources != null ? de___listOfBridgeSource(output.sources, context) : undefined,
+    };
+};
+const de_BridgeFlowOutput = (output, context) => {
+    return {
+        FlowArn: __expectString(output.flowArn),
+        FlowSourceArn: __expectString(output.flowSourceArn),
+        Name: __expectString(output.name),
+    };
+};
+const de_BridgeFlowSource = (output, context) => {
+    return {
+        FlowArn: __expectString(output.flowArn),
+        FlowVpcInterfaceAttachment: output.flowVpcInterfaceAttachment != null
+            ? de_VpcInterfaceAttachment(output.flowVpcInterfaceAttachment, context)
+            : undefined,
+        Name: __expectString(output.name),
+        OutputArn: __expectString(output.outputArn),
+    };
+};
+const de_BridgeNetworkOutput = (output, context) => {
+    return {
+        IpAddress: __expectString(output.ipAddress),
+        Name: __expectString(output.name),
+        NetworkName: __expectString(output.networkName),
+        Port: __expectInt32(output.port),
+        Protocol: __expectString(output.protocol),
+        Ttl: __expectInt32(output.ttl),
+    };
+};
+const de_BridgeNetworkSource = (output, context) => {
+    return {
+        MulticastIp: __expectString(output.multicastIp),
+        Name: __expectString(output.name),
+        NetworkName: __expectString(output.networkName),
+        Port: __expectInt32(output.port),
+        Protocol: __expectString(output.protocol),
+    };
+};
+const de_BridgeOutput = (output, context) => {
+    return {
+        FlowOutput: output.flowOutput != null ? de_BridgeFlowOutput(output.flowOutput, context) : undefined,
+        NetworkOutput: output.networkOutput != null ? de_BridgeNetworkOutput(output.networkOutput, context) : undefined,
+    };
+};
+const de_BridgeSource = (output, context) => {
+    return {
+        FlowSource: output.flowSource != null ? de_BridgeFlowSource(output.flowSource, context) : undefined,
+        NetworkSource: output.networkSource != null ? de_BridgeNetworkSource(output.networkSource, context) : undefined,
+    };
+};
 const de_DestinationConfiguration = (output, context) => {
     return {
         DestinationIp: __expectString(output.destinationIp),
@@ -2666,6 +4448,12 @@ const de_DestinationConfiguration = (output, context) => {
         OutboundIp: __expectString(output.outboundIp),
     };
 };
+const de_EgressGatewayBridge = (output, context) => {
+    return {
+        InstanceId: __expectString(output.instanceId),
+        MaxBitrate: __expectInt32(output.maxBitrate),
+    };
+};
 const de_EncodingParameters = (output, context) => {
     return {
         CompressionFactor: __limitedParseDouble(output.compressionFactor),
@@ -2733,6 +4521,49 @@ const de_Fmtp = (output, context) => {
         Tcs: __expectString(output.tcs),
     };
 };
+const de_Gateway = (output, context) => {
+    return {
+        EgressCidrBlocks: output.egressCidrBlocks != null ? de___listOf__string(output.egressCidrBlocks, context) : undefined,
+        GatewayArn: __expectString(output.gatewayArn),
+        GatewayMessages: output.gatewayMessages != null ? de___listOfMessageDetail(output.gatewayMessages, context) : undefined,
+        GatewayState: __expectString(output.gatewayState),
+        Name: __expectString(output.name),
+        Networks: output.networks != null ? de___listOfGatewayNetwork(output.networks, context) : undefined,
+    };
+};
+const de_GatewayBridgeSource = (output, context) => {
+    return {
+        BridgeArn: __expectString(output.bridgeArn),
+        VpcInterfaceAttachment: output.vpcInterfaceAttachment != null
+            ? de_VpcInterfaceAttachment(output.vpcInterfaceAttachment, context)
+            : undefined,
+    };
+};
+const de_GatewayInstance = (output, context) => {
+    return {
+        BridgePlacement: __expectString(output.bridgePlacement),
+        ConnectionStatus: __expectString(output.connectionStatus),
+        GatewayArn: __expectString(output.gatewayArn),
+        GatewayInstanceArn: __expectString(output.gatewayInstanceArn),
+        InstanceId: __expectString(output.instanceId),
+        InstanceMessages: output.instanceMessages != null ? de___listOfMessageDetail(output.instanceMessages, context) : undefined,
+        InstanceState: __expectString(output.instanceState),
+        RunningBridgeCount: __expectInt32(output.runningBridgeCount),
+    };
+};
+const de_GatewayNetwork = (output, context) => {
+    return {
+        CidrBlock: __expectString(output.cidrBlock),
+        Name: __expectString(output.name),
+    };
+};
+const de_IngressGatewayBridge = (output, context) => {
+    return {
+        InstanceId: __expectString(output.instanceId),
+        MaxBitrate: __expectInt32(output.maxBitrate),
+        MaxOutputs: __expectInt32(output.maxOutputs),
+    };
+};
 const de_InputConfiguration = (output, context) => {
     return {
         InputIp: __expectString(output.inputIp),
@@ -2745,6 +4576,15 @@ const de_Interface = (output, context) => {
         Name: __expectString(output.name),
     };
 };
+const de_ListedBridge = (output, context) => {
+    return {
+        BridgeArn: __expectString(output.bridgeArn),
+        BridgeState: __expectString(output.bridgeState),
+        BridgeType: __expectString(output.bridgeType),
+        Name: __expectString(output.name),
+        PlacementArn: __expectString(output.placementArn),
+    };
+};
 const de_ListedEntitlement = (output, context) => {
     return {
         DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
@@ -2763,6 +4603,21 @@ const de_ListedFlow = (output, context) => {
         Status: __expectString(output.status),
     };
 };
+const de_ListedGateway = (output, context) => {
+    return {
+        GatewayArn: __expectString(output.gatewayArn),
+        GatewayState: __expectString(output.gatewayState),
+        Name: __expectString(output.name),
+    };
+};
+const de_ListedGatewayInstance = (output, context) => {
+    return {
+        GatewayArn: __expectString(output.gatewayArn),
+        GatewayInstanceArn: __expectString(output.gatewayInstanceArn),
+        InstanceId: __expectString(output.instanceId),
+        InstanceState: __expectString(output.instanceState),
+    };
+};
 const de_Maintenance = (output, context) => {
     return {
         MaintenanceDay: __expectString(output.maintenanceDay),
@@ -2808,6 +4663,13 @@ const de_MediaStreamSourceConfiguration = (output, context) => {
         MediaStreamName: __expectString(output.mediaStreamName),
     };
 };
+const de_MessageDetail = (output, context) => {
+    return {
+        Code: __expectString(output.code),
+        Message: __expectString(output.message),
+        ResourceName: __expectString(output.resourceName),
+    };
+};
 const de_Messages = (output, context) => {
     return {
         Errors: output.errors != null ? de___listOf__string(output.errors, context) : undefined,
@@ -2829,6 +4691,8 @@ const de_Offering = (output, context) => {
 };
 const de_Output = (output, context) => {
     return {
+        BridgeArn: __expectString(output.bridgeArn),
+        BridgePorts: output.bridgePorts != null ? de___listOf__integer(output.bridgePorts, context) : undefined,
         DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
         Description: __expectString(output.description),
         Destination: __expectString(output.destination),
@@ -2879,6 +4743,7 @@ const de_Source = (output, context) => {
         Decryption: output.decryption != null ? de_Encryption(output.decryption, context) : undefined,
         Description: __expectString(output.description),
         EntitlementArn: __expectString(output.entitlementArn),
+        GatewayBridgeSource: output.gatewayBridgeSource != null ? de_GatewayBridgeSource(output.gatewayBridgeSource, context) : undefined,
         IngestIp: __expectString(output.ingestIp),
         IngestPort: __expectInt32(output.ingestPort),
         MediaStreamSourceConfigurations: output.mediaStreamSourceConfigurations != null