@aws-sdk/client-mediaconnect 3.312.0 → 3.313.0

package/dist-es/MediaConnect.js

@@ -1,19 +1,34 @@
+import { AddBridgeOutputsCommand, } from "./commands/AddBridgeOutputsCommand";
+import { AddBridgeSourcesCommand, } from "./commands/AddBridgeSourcesCommand";
 import { AddFlowMediaStreamsCommand, } from "./commands/AddFlowMediaStreamsCommand";
 import { AddFlowOutputsCommand, } from "./commands/AddFlowOutputsCommand";
 import { AddFlowSourcesCommand, } from "./commands/AddFlowSourcesCommand";
 import { AddFlowVpcInterfacesCommand, } from "./commands/AddFlowVpcInterfacesCommand";
+import { CreateBridgeCommand, } from "./commands/CreateBridgeCommand";
 import { CreateFlowCommand } from "./commands/CreateFlowCommand";
+import { CreateGatewayCommand, } from "./commands/CreateGatewayCommand";
+import { DeleteBridgeCommand, } from "./commands/DeleteBridgeCommand";
 import { DeleteFlowCommand } from "./commands/DeleteFlowCommand";
+import { DeleteGatewayCommand, } from "./commands/DeleteGatewayCommand";
+import { DeregisterGatewayInstanceCommand, } from "./commands/DeregisterGatewayInstanceCommand";
+import { DescribeBridgeCommand, } from "./commands/DescribeBridgeCommand";
 import { DescribeFlowCommand, } from "./commands/DescribeFlowCommand";
+import { DescribeGatewayCommand, } from "./commands/DescribeGatewayCommand";
+import { DescribeGatewayInstanceCommand, } from "./commands/DescribeGatewayInstanceCommand";
 import { DescribeOfferingCommand, } from "./commands/DescribeOfferingCommand";
 import { DescribeReservationCommand, } from "./commands/DescribeReservationCommand";
 import { GrantFlowEntitlementsCommand, } from "./commands/GrantFlowEntitlementsCommand";
+import { ListBridgesCommand } from "./commands/ListBridgesCommand";
 import { ListEntitlementsCommand, } from "./commands/ListEntitlementsCommand";
 import { ListFlowsCommand } from "./commands/ListFlowsCommand";
+import { ListGatewayInstancesCommand, } from "./commands/ListGatewayInstancesCommand";
+import { ListGatewaysCommand, } from "./commands/ListGatewaysCommand";
 import { ListOfferingsCommand, } from "./commands/ListOfferingsCommand";
 import { ListReservationsCommand, } from "./commands/ListReservationsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { PurchaseOfferingCommand, } from "./commands/PurchaseOfferingCommand";
+import { RemoveBridgeOutputCommand, } from "./commands/RemoveBridgeOutputCommand";
+import { RemoveBridgeSourceCommand, } from "./commands/RemoveBridgeSourceCommand";
 import { RemoveFlowMediaStreamCommand, } from "./commands/RemoveFlowMediaStreamCommand";
 import { RemoveFlowOutputCommand, } from "./commands/RemoveFlowOutputCommand";
 import { RemoveFlowSourceCommand, } from "./commands/RemoveFlowSourceCommand";
@@ -23,13 +38,46 @@ import { StartFlowCommand } from "./commands/StartFlowCommand";
 import { StopFlowCommand } from "./commands/StopFlowCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
+import { UpdateBridgeCommand, } from "./commands/UpdateBridgeCommand";
+import { UpdateBridgeOutputCommand, } from "./commands/UpdateBridgeOutputCommand";
+import { UpdateBridgeSourceCommand, } from "./commands/UpdateBridgeSourceCommand";
+import { UpdateBridgeStateCommand, } from "./commands/UpdateBridgeStateCommand";
 import { UpdateFlowCommand } from "./commands/UpdateFlowCommand";
 import { UpdateFlowEntitlementCommand, } from "./commands/UpdateFlowEntitlementCommand";
 import { UpdateFlowMediaStreamCommand, } from "./commands/UpdateFlowMediaStreamCommand";
 import { UpdateFlowOutputCommand, } from "./commands/UpdateFlowOutputCommand";
 import { UpdateFlowSourceCommand, } from "./commands/UpdateFlowSourceCommand";
+import { UpdateGatewayInstanceCommand, } from "./commands/UpdateGatewayInstanceCommand";
 import { MediaConnectClient } from "./MediaConnectClient";
 export class MediaConnect extends MediaConnectClient {
+    addBridgeOutputs(args, optionsOrCb, cb) {
+        const command = new AddBridgeOutputsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    addBridgeSources(args, optionsOrCb, cb) {
+        const command = new AddBridgeSourcesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     addFlowMediaStreams(args, optionsOrCb, cb) {
         const command = new AddFlowMediaStreamsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -86,6 +134,20 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createBridge(args, optionsOrCb, cb) {
+        const command = new CreateBridgeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createFlow(args, optionsOrCb, cb) {
         const command = new CreateFlowCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -100,6 +162,34 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createGateway(args, optionsOrCb, cb) {
+        const command = new CreateGatewayCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteBridge(args, optionsOrCb, cb) {
+        const command = new DeleteBridgeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteFlow(args, optionsOrCb, cb) {
         const command = new DeleteFlowCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -114,6 +204,48 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteGateway(args, optionsOrCb, cb) {
+        const command = new DeleteGatewayCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deregisterGatewayInstance(args, optionsOrCb, cb) {
+        const command = new DeregisterGatewayInstanceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    describeBridge(args, optionsOrCb, cb) {
+        const command = new DescribeBridgeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     describeFlow(args, optionsOrCb, cb) {
         const command = new DescribeFlowCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -128,6 +260,34 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    describeGateway(args, optionsOrCb, cb) {
+        const command = new DescribeGatewayCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    describeGatewayInstance(args, optionsOrCb, cb) {
+        const command = new DescribeGatewayInstanceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     describeOffering(args, optionsOrCb, cb) {
         const command = new DescribeOfferingCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -170,6 +330,20 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listBridges(args, optionsOrCb, cb) {
+        const command = new ListBridgesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listEntitlements(args, optionsOrCb, cb) {
         const command = new ListEntitlementsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -198,6 +372,34 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listGatewayInstances(args, optionsOrCb, cb) {
+        const command = new ListGatewayInstancesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listGateways(args, optionsOrCb, cb) {
+        const command = new ListGatewaysCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listOfferings(args, optionsOrCb, cb) {
         const command = new ListOfferingsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -254,6 +456,34 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    removeBridgeOutput(args, optionsOrCb, cb) {
+        const command = new RemoveBridgeOutputCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    removeBridgeSource(args, optionsOrCb, cb) {
+        const command = new RemoveBridgeSourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     removeFlowMediaStream(args, optionsOrCb, cb) {
         const command = new RemoveFlowMediaStreamCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -380,6 +610,62 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateBridge(args, optionsOrCb, cb) {
+        const command = new UpdateBridgeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateBridgeOutput(args, optionsOrCb, cb) {
+        const command = new UpdateBridgeOutputCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateBridgeSource(args, optionsOrCb, cb) {
+        const command = new UpdateBridgeSourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateBridgeState(args, optionsOrCb, cb) {
+        const command = new UpdateBridgeStateCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     updateFlow(args, optionsOrCb, cb) {
         const command = new UpdateFlowCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -450,4 +736,18 @@ export class MediaConnect extends MediaConnectClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateGatewayInstance(args, optionsOrCb, cb) {
+        const command = new UpdateGatewayInstanceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
 }

package/dist-es/commands/AddBridgeOutputsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_AddBridgeOutputsCommand, se_AddBridgeOutputsCommand } from "../protocols/Aws_restJson1";
+export class AddBridgeOutputsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, AddBridgeOutputsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaConnectClient";
+        const commandName = "AddBridgeOutputsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_AddBridgeOutputsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_AddBridgeOutputsCommand(output, context);
+    }
+}

package/dist-es/commands/AddBridgeSourcesCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_AddBridgeSourcesCommand, se_AddBridgeSourcesCommand } from "../protocols/Aws_restJson1";
+export class AddBridgeSourcesCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, AddBridgeSourcesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaConnectClient";
+        const commandName = "AddBridgeSourcesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_AddBridgeSourcesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_AddBridgeSourcesCommand(output, context);
+    }
+}

package/dist-es/commands/CreateBridgeCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_CreateBridgeCommand, se_CreateBridgeCommand } from "../protocols/Aws_restJson1";
+export class CreateBridgeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateBridgeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaConnectClient";
+        const commandName = "CreateBridgeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateBridgeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateBridgeCommand(output, context);
+    }
+}

package/dist-es/commands/CreateGatewayCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_CreateGatewayCommand, se_CreateGatewayCommand } from "../protocols/Aws_restJson1";
+export class CreateGatewayCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateGatewayCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaConnectClient";
+        const commandName = "CreateGatewayCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateGatewayCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateGatewayCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteBridgeCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DeleteBridgeCommand, se_DeleteBridgeCommand } from "../protocols/Aws_restJson1";
+export class DeleteBridgeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteBridgeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaConnectClient";
+        const commandName = "DeleteBridgeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteBridgeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteBridgeCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteGatewayCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DeleteGatewayCommand, se_DeleteGatewayCommand } from "../protocols/Aws_restJson1";
+export class DeleteGatewayCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteGatewayCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaConnectClient";
+        const commandName = "DeleteGatewayCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteGatewayCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteGatewayCommand(output, context);
+    }
+}