@aws-sdk/client-mediaconnect 3.183.0 → 3.185.0

package/dist-es/commands/AddFlowMediaStreamsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AddFlowMediaStreamsRequestFilterSensitiveLog, AddFlowMediaStreamsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1AddFlowMediaStreamsCommand, serializeAws_restJson1AddFlowMediaStreamsCommand, } from "../protocols/Aws_restJson1";
-export class AddFlowMediaStreamsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AddFlowMediaStreamsCommand = (function (_super) {
+    __extends(AddFlowMediaStreamsCommand, _super);
+    function AddFlowMediaStreamsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AddFlowMediaStreamsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "AddFlowMediaStreamsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "AddFlowMediaStreamsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AddFlowMediaStreamsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AddFlowMediaStreamsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AddFlowMediaStreamsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1AddFlowMediaStreamsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AddFlowMediaStreamsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1AddFlowMediaStreamsCommand(output, context);
-    }
-}
+    };
+    return AddFlowMediaStreamsCommand;
+}($Command));
+export { AddFlowMediaStreamsCommand };

package/dist-es/commands/AddFlowOutputsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AddFlowOutputsRequestFilterSensitiveLog, AddFlowOutputsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1AddFlowOutputsCommand, serializeAws_restJson1AddFlowOutputsCommand, } from "../protocols/Aws_restJson1";
-export class AddFlowOutputsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AddFlowOutputsCommand = (function (_super) {
+    __extends(AddFlowOutputsCommand, _super);
+    function AddFlowOutputsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AddFlowOutputsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "AddFlowOutputsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "AddFlowOutputsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AddFlowOutputsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AddFlowOutputsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AddFlowOutputsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1AddFlowOutputsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AddFlowOutputsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1AddFlowOutputsCommand(output, context);
-    }
-}
+    };
+    return AddFlowOutputsCommand;
+}($Command));
+export { AddFlowOutputsCommand };

package/dist-es/commands/AddFlowSourcesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AddFlowSourcesRequestFilterSensitiveLog, AddFlowSourcesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1AddFlowSourcesCommand, serializeAws_restJson1AddFlowSourcesCommand, } from "../protocols/Aws_restJson1";
-export class AddFlowSourcesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AddFlowSourcesCommand = (function (_super) {
+    __extends(AddFlowSourcesCommand, _super);
+    function AddFlowSourcesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AddFlowSourcesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "AddFlowSourcesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "AddFlowSourcesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AddFlowSourcesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AddFlowSourcesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AddFlowSourcesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1AddFlowSourcesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AddFlowSourcesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1AddFlowSourcesCommand(output, context);
-    }
-}
+    };
+    return AddFlowSourcesCommand;
+}($Command));
+export { AddFlowSourcesCommand };

package/dist-es/commands/AddFlowVpcInterfacesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AddFlowVpcInterfacesRequestFilterSensitiveLog, AddFlowVpcInterfacesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1AddFlowVpcInterfacesCommand, serializeAws_restJson1AddFlowVpcInterfacesCommand, } from "../protocols/Aws_restJson1";
-export class AddFlowVpcInterfacesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AddFlowVpcInterfacesCommand = (function (_super) {
+    __extends(AddFlowVpcInterfacesCommand, _super);
+    function AddFlowVpcInterfacesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AddFlowVpcInterfacesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "AddFlowVpcInterfacesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "AddFlowVpcInterfacesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AddFlowVpcInterfacesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AddFlowVpcInterfacesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AddFlowVpcInterfacesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1AddFlowVpcInterfacesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AddFlowVpcInterfacesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1AddFlowVpcInterfacesCommand(output, context);
-    }
-}
+    };
+    return AddFlowVpcInterfacesCommand;
+}($Command));
+export { AddFlowVpcInterfacesCommand };

package/dist-es/commands/CreateFlowCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateFlowRequestFilterSensitiveLog, CreateFlowResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateFlowCommand, serializeAws_restJson1CreateFlowCommand, } from "../protocols/Aws_restJson1";
-export class CreateFlowCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateFlowCommand = (function (_super) {
+    __extends(CreateFlowCommand, _super);
+    function CreateFlowCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateFlowCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "CreateFlowCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "CreateFlowCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateFlowRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateFlowResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateFlowCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateFlowCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateFlowCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateFlowCommand(output, context);
-    }
-}
+    };
+    return CreateFlowCommand;
+}($Command));
+export { CreateFlowCommand };

package/dist-es/commands/DeleteFlowCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteFlowRequestFilterSensitiveLog, DeleteFlowResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteFlowCommand, serializeAws_restJson1DeleteFlowCommand, } from "../protocols/Aws_restJson1";
-export class DeleteFlowCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteFlowCommand = (function (_super) {
+    __extends(DeleteFlowCommand, _super);
+    function DeleteFlowCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteFlowCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "DeleteFlowCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "DeleteFlowCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteFlowRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteFlowResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteFlowCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteFlowCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteFlowCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteFlowCommand(output, context);
-    }
-}
+    };
+    return DeleteFlowCommand;
+}($Command));
+export { DeleteFlowCommand };

package/dist-es/commands/DescribeFlowCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeFlowRequestFilterSensitiveLog, DescribeFlowResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeFlowCommand, serializeAws_restJson1DescribeFlowCommand, } from "../protocols/Aws_restJson1";
-export class DescribeFlowCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeFlowCommand = (function (_super) {
+    __extends(DescribeFlowCommand, _super);
+    function DescribeFlowCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeFlowCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "DescribeFlowCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "DescribeFlowCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeFlowRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeFlowResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeFlowCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeFlowCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeFlowCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeFlowCommand(output, context);
-    }
-}
+    };
+    return DescribeFlowCommand;
+}($Command));
+export { DescribeFlowCommand };

package/dist-es/commands/DescribeOfferingCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeOfferingRequestFilterSensitiveLog, DescribeOfferingResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeOfferingCommand, serializeAws_restJson1DescribeOfferingCommand, } from "../protocols/Aws_restJson1";
-export class DescribeOfferingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeOfferingCommand = (function (_super) {
+    __extends(DescribeOfferingCommand, _super);
+    function DescribeOfferingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeOfferingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "DescribeOfferingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "DescribeOfferingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeOfferingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeOfferingResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeOfferingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeOfferingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeOfferingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeOfferingCommand(output, context);
-    }
-}
+    };
+    return DescribeOfferingCommand;
+}($Command));
+export { DescribeOfferingCommand };

package/dist-es/commands/DescribeReservationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeReservationRequestFilterSensitiveLog, DescribeReservationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeReservationCommand, serializeAws_restJson1DescribeReservationCommand, } from "../protocols/Aws_restJson1";
-export class DescribeReservationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeReservationCommand = (function (_super) {
+    __extends(DescribeReservationCommand, _super);
+    function DescribeReservationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeReservationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "DescribeReservationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "DescribeReservationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeReservationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeReservationResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeReservationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeReservationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeReservationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeReservationCommand(output, context);
-    }
-}
+    };
+    return DescribeReservationCommand;
+}($Command));
+export { DescribeReservationCommand };

package/dist-es/commands/GrantFlowEntitlementsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GrantFlowEntitlementsRequestFilterSensitiveLog, GrantFlowEntitlementsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GrantFlowEntitlementsCommand, serializeAws_restJson1GrantFlowEntitlementsCommand, } from "../protocols/Aws_restJson1";
-export class GrantFlowEntitlementsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GrantFlowEntitlementsCommand = (function (_super) {
+    __extends(GrantFlowEntitlementsCommand, _super);
+    function GrantFlowEntitlementsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GrantFlowEntitlementsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaConnectClient";
-        const commandName = "GrantFlowEntitlementsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaConnectClient";
+        var commandName = "GrantFlowEntitlementsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GrantFlowEntitlementsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GrantFlowEntitlementsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GrantFlowEntitlementsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GrantFlowEntitlementsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GrantFlowEntitlementsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GrantFlowEntitlementsCommand(output, context);
-    }
-}
+    };
+    return GrantFlowEntitlementsCommand;
+}($Command));
+export { GrantFlowEntitlementsCommand };