@aws-sdk/client-medialive 3.183.0 → 3.186.0

package/dist-es/commands/CreateInputSecurityGroupCommand.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 { CreateInputSecurityGroupRequestFilterSensitiveLog, CreateInputSecurityGroupResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1CreateInputSecurityGroupCommand, serializeAws_restJson1CreateInputSecurityGroupCommand, } from "../protocols/Aws_restJson1";
-export class CreateInputSecurityGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateInputSecurityGroupCommand = (function (_super) {
+    __extends(CreateInputSecurityGroupCommand, _super);
+    function CreateInputSecurityGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateInputSecurityGroupCommand.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 = "MediaLiveClient";
-        const commandName = "CreateInputSecurityGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateInputSecurityGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateInputSecurityGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateInputSecurityGroupResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateInputSecurityGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateInputSecurityGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateInputSecurityGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateInputSecurityGroupCommand(output, context);
-    }
-}
+    };
+    return CreateInputSecurityGroupCommand;
+}($Command));
+export { CreateInputSecurityGroupCommand };

package/dist-es/commands/CreateMultiplexCommand.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 { CreateMultiplexRequestFilterSensitiveLog, CreateMultiplexResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1CreateMultiplexCommand, serializeAws_restJson1CreateMultiplexCommand, } from "../protocols/Aws_restJson1";
-export class CreateMultiplexCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateMultiplexCommand = (function (_super) {
+    __extends(CreateMultiplexCommand, _super);
+    function CreateMultiplexCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateMultiplexCommand.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 = "MediaLiveClient";
-        const commandName = "CreateMultiplexCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateMultiplexCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateMultiplexRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateMultiplexResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateMultiplexCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateMultiplexCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateMultiplexCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateMultiplexCommand(output, context);
-    }
-}
+    };
+    return CreateMultiplexCommand;
+}($Command));
+export { CreateMultiplexCommand };

package/dist-es/commands/CreateMultiplexProgramCommand.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 { CreateMultiplexProgramRequestFilterSensitiveLog, CreateMultiplexProgramResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1CreateMultiplexProgramCommand, serializeAws_restJson1CreateMultiplexProgramCommand, } from "../protocols/Aws_restJson1";
-export class CreateMultiplexProgramCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateMultiplexProgramCommand = (function (_super) {
+    __extends(CreateMultiplexProgramCommand, _super);
+    function CreateMultiplexProgramCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateMultiplexProgramCommand.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 = "MediaLiveClient";
-        const commandName = "CreateMultiplexProgramCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateMultiplexProgramCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateMultiplexProgramRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateMultiplexProgramResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateMultiplexProgramCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateMultiplexProgramCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateMultiplexProgramCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateMultiplexProgramCommand(output, context);
-    }
-}
+    };
+    return CreateMultiplexProgramCommand;
+}($Command));
+export { CreateMultiplexProgramCommand };

package/dist-es/commands/CreatePartnerInputCommand.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 { CreatePartnerInputRequestFilterSensitiveLog, CreatePartnerInputResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1CreatePartnerInputCommand, serializeAws_restJson1CreatePartnerInputCommand, } from "../protocols/Aws_restJson1";
-export class CreatePartnerInputCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreatePartnerInputCommand = (function (_super) {
+    __extends(CreatePartnerInputCommand, _super);
+    function CreatePartnerInputCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreatePartnerInputCommand.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 = "MediaLiveClient";
-        const commandName = "CreatePartnerInputCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreatePartnerInputCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreatePartnerInputRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreatePartnerInputResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreatePartnerInputCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreatePartnerInputCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreatePartnerInputCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreatePartnerInputCommand(output, context);
-    }
-}
+    };
+    return CreatePartnerInputCommand;
+}($Command));
+export { CreatePartnerInputCommand };

package/dist-es/commands/CreateTagsCommand.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 { CreateTagsRequestFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_restJson1CreateTagsCommand, serializeAws_restJson1CreateTagsCommand, } from "../protocols/Aws_restJson1";
-export class CreateTagsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateTagsCommand = (function (_super) {
+    __extends(CreateTagsCommand, _super);
+    function CreateTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateTagsCommand.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 = "MediaLiveClient";
-        const commandName = "CreateTagsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateTagsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateTagsRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    CreateTagsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateTagsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateTagsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateTagsCommand(output, context);
-    }
-}
+    };
+    return CreateTagsCommand;
+}($Command));
+export { CreateTagsCommand };

package/dist-es/commands/DeleteChannelCommand.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 { DeleteChannelRequestFilterSensitiveLog, DeleteChannelResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1DeleteChannelCommand, serializeAws_restJson1DeleteChannelCommand, } from "../protocols/Aws_restJson1";
-export class DeleteChannelCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteChannelCommand = (function (_super) {
+    __extends(DeleteChannelCommand, _super);
+    function DeleteChannelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteChannelCommand.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 = "MediaLiveClient";
-        const commandName = "DeleteChannelCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "DeleteChannelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteChannelRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteChannelResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteChannelCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteChannelCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteChannelCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteChannelCommand(output, context);
-    }
-}
+    };
+    return DeleteChannelCommand;
+}($Command));
+export { DeleteChannelCommand };

package/dist-es/commands/DeleteInputCommand.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 { DeleteInputRequestFilterSensitiveLog, DeleteInputResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1DeleteInputCommand, serializeAws_restJson1DeleteInputCommand, } from "../protocols/Aws_restJson1";
-export class DeleteInputCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteInputCommand = (function (_super) {
+    __extends(DeleteInputCommand, _super);
+    function DeleteInputCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteInputCommand.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 = "MediaLiveClient";
-        const commandName = "DeleteInputCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "DeleteInputCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteInputRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteInputResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteInputCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteInputCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteInputCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteInputCommand(output, context);
-    }
-}
+    };
+    return DeleteInputCommand;
+}($Command));
+export { DeleteInputCommand };

package/dist-es/commands/DeleteInputSecurityGroupCommand.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 { DeleteInputSecurityGroupRequestFilterSensitiveLog, DeleteInputSecurityGroupResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1DeleteInputSecurityGroupCommand, serializeAws_restJson1DeleteInputSecurityGroupCommand, } from "../protocols/Aws_restJson1";
-export class DeleteInputSecurityGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteInputSecurityGroupCommand = (function (_super) {
+    __extends(DeleteInputSecurityGroupCommand, _super);
+    function DeleteInputSecurityGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteInputSecurityGroupCommand.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 = "MediaLiveClient";
-        const commandName = "DeleteInputSecurityGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "DeleteInputSecurityGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteInputSecurityGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteInputSecurityGroupResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteInputSecurityGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteInputSecurityGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteInputSecurityGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteInputSecurityGroupCommand(output, context);
-    }
-}
+    };
+    return DeleteInputSecurityGroupCommand;
+}($Command));
+export { DeleteInputSecurityGroupCommand };

package/dist-es/commands/DeleteMultiplexCommand.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 { DeleteMultiplexRequestFilterSensitiveLog, DeleteMultiplexResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1DeleteMultiplexCommand, serializeAws_restJson1DeleteMultiplexCommand, } from "../protocols/Aws_restJson1";
-export class DeleteMultiplexCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteMultiplexCommand = (function (_super) {
+    __extends(DeleteMultiplexCommand, _super);
+    function DeleteMultiplexCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteMultiplexCommand.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 = "MediaLiveClient";
-        const commandName = "DeleteMultiplexCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "DeleteMultiplexCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteMultiplexRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteMultiplexResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteMultiplexCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteMultiplexCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteMultiplexCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteMultiplexCommand(output, context);
-    }
-}
+    };
+    return DeleteMultiplexCommand;
+}($Command));
+export { DeleteMultiplexCommand };

package/dist-es/commands/DeleteMultiplexProgramCommand.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 { DeleteMultiplexProgramRequestFilterSensitiveLog, DeleteMultiplexProgramResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1DeleteMultiplexProgramCommand, serializeAws_restJson1DeleteMultiplexProgramCommand, } from "../protocols/Aws_restJson1";
-export class DeleteMultiplexProgramCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteMultiplexProgramCommand = (function (_super) {
+    __extends(DeleteMultiplexProgramCommand, _super);
+    function DeleteMultiplexProgramCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteMultiplexProgramCommand.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 = "MediaLiveClient";
-        const commandName = "DeleteMultiplexProgramCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "DeleteMultiplexProgramCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteMultiplexProgramRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteMultiplexProgramResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteMultiplexProgramCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteMultiplexProgramCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteMultiplexProgramCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteMultiplexProgramCommand(output, context);
-    }
-}
+    };
+    return DeleteMultiplexProgramCommand;
+}($Command));
+export { DeleteMultiplexProgramCommand };