@aws-sdk/client-forecast 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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