@aws-sdk/client-machine-learning 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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