@aws-sdk/client-kinesis 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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