@aws-sdk/client-forecast 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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