@aws-sdk/client-ivs 3.183.0 → 3.185.0

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

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

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

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

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

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 } from "../models/models_0";
 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 = "IvsClient";
-        const commandName = "DeleteChannelCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IvsClient";
+        var commandName = "DeleteChannelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteChannelRequestFilterSensitiveLog,
-            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);
+    };
+    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/DeletePlaybackKeyPairCommand.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 { DeletePlaybackKeyPairRequestFilterSensitiveLog, DeletePlaybackKeyPairResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeletePlaybackKeyPairCommand, serializeAws_restJson1DeletePlaybackKeyPairCommand, } from "../protocols/Aws_restJson1";
-export class DeletePlaybackKeyPairCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeletePlaybackKeyPairCommand = (function (_super) {
+    __extends(DeletePlaybackKeyPairCommand, _super);
+    function DeletePlaybackKeyPairCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeletePlaybackKeyPairCommand.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 = "IvsClient";
-        const commandName = "DeletePlaybackKeyPairCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IvsClient";
+        var commandName = "DeletePlaybackKeyPairCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeletePlaybackKeyPairRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeletePlaybackKeyPairResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DeletePlaybackKeyPairCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeletePlaybackKeyPairCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeletePlaybackKeyPairCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeletePlaybackKeyPairCommand(output, context);
-    }
-}
+    };
+    return DeletePlaybackKeyPairCommand;
+}($Command));
+export { DeletePlaybackKeyPairCommand };

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

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

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