@aws-sdk/client-ivs 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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