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

package/dist-es/commands/AddTagsCommand.js

@@ -1,39 +1,32 @@
-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";
-var AddTagsCommand = (function (_super) {
-    __extends(AddTagsCommand, _super);
-    function AddTagsCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class AddTagsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    AddTagsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "AddTagsCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "AddTagsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: AddTagsInputFilterSensitiveLog,
             outputFilterSensitiveLog: AddTagsOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    AddTagsCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1AddTagsCommand(input, context);
-    };
-    AddTagsCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1AddTagsCommand(output, context);
-    };
-    return AddTagsCommand;
-}($Command));
-export { AddTagsCommand };
+    }
+}

package/dist-es/commands/CreateBatchPredictionCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateBatchPredictionCommand = (function (_super) {
-    __extends(CreateBatchPredictionCommand, _super);
-    function CreateBatchPredictionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateBatchPredictionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateBatchPredictionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "CreateBatchPredictionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "CreateBatchPredictionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateBatchPredictionInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateBatchPredictionOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateBatchPredictionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1CreateBatchPredictionCommand(input, context);
-    };
-    CreateBatchPredictionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1CreateBatchPredictionCommand(output, context);
-    };
-    return CreateBatchPredictionCommand;
-}($Command));
-export { CreateBatchPredictionCommand };
+    }
+}

package/dist-es/commands/CreateDataSourceFromRDSCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateDataSourceFromRDSCommand = (function (_super) {
-    __extends(CreateDataSourceFromRDSCommand, _super);
-    function CreateDataSourceFromRDSCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDataSourceFromRDSCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDataSourceFromRDSCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "CreateDataSourceFromRDSCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "CreateDataSourceFromRDSCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDataSourceFromRDSInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDataSourceFromRDSOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDataSourceFromRDSCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1CreateDataSourceFromRDSCommand(input, context);
-    };
-    CreateDataSourceFromRDSCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1CreateDataSourceFromRDSCommand(output, context);
-    };
-    return CreateDataSourceFromRDSCommand;
-}($Command));
-export { CreateDataSourceFromRDSCommand };
+    }
+}

package/dist-es/commands/CreateDataSourceFromRedshiftCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateDataSourceFromRedshiftCommand = (function (_super) {
-    __extends(CreateDataSourceFromRedshiftCommand, _super);
-    function CreateDataSourceFromRedshiftCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDataSourceFromRedshiftCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDataSourceFromRedshiftCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "CreateDataSourceFromRedshiftCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "CreateDataSourceFromRedshiftCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDataSourceFromRedshiftInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDataSourceFromRedshiftOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDataSourceFromRedshiftCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1CreateDataSourceFromRedshiftCommand(input, context);
-    };
-    CreateDataSourceFromRedshiftCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1CreateDataSourceFromRedshiftCommand(output, context);
-    };
-    return CreateDataSourceFromRedshiftCommand;
-}($Command));
-export { CreateDataSourceFromRedshiftCommand };
+    }
+}

package/dist-es/commands/CreateDataSourceFromS3Command.js

@@ -1,39 +1,32 @@
-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";
-var CreateDataSourceFromS3Command = (function (_super) {
-    __extends(CreateDataSourceFromS3Command, _super);
-    function CreateDataSourceFromS3Command(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDataSourceFromS3Command extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDataSourceFromS3Command.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "CreateDataSourceFromS3Command";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "CreateDataSourceFromS3Command";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDataSourceFromS3InputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDataSourceFromS3OutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDataSourceFromS3Command.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1CreateDataSourceFromS3Command(input, context);
-    };
-    CreateDataSourceFromS3Command.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1CreateDataSourceFromS3Command(output, context);
-    };
-    return CreateDataSourceFromS3Command;
-}($Command));
-export { CreateDataSourceFromS3Command };
+    }
+}

package/dist-es/commands/CreateEvaluationCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateEvaluationCommand = (function (_super) {
-    __extends(CreateEvaluationCommand, _super);
-    function CreateEvaluationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateEvaluationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateEvaluationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "CreateEvaluationCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "CreateEvaluationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateEvaluationInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateEvaluationOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateEvaluationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1CreateEvaluationCommand(input, context);
-    };
-    CreateEvaluationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1CreateEvaluationCommand(output, context);
-    };
-    return CreateEvaluationCommand;
-}($Command));
-export { CreateEvaluationCommand };
+    }
+}

package/dist-es/commands/CreateMLModelCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateMLModelCommand = (function (_super) {
-    __extends(CreateMLModelCommand, _super);
-    function CreateMLModelCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateMLModelCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateMLModelCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "CreateMLModelCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "CreateMLModelCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateMLModelInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateMLModelOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateMLModelCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1CreateMLModelCommand(input, context);
-    };
-    CreateMLModelCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1CreateMLModelCommand(output, context);
-    };
-    return CreateMLModelCommand;
-}($Command));
-export { CreateMLModelCommand };
+    }
+}

package/dist-es/commands/CreateRealtimeEndpointCommand.js

@@ -1,39 +1,32 @@
-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";
-var CreateRealtimeEndpointCommand = (function (_super) {
-    __extends(CreateRealtimeEndpointCommand, _super);
-    function CreateRealtimeEndpointCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateRealtimeEndpointCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateRealtimeEndpointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "CreateRealtimeEndpointCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "CreateRealtimeEndpointCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateRealtimeEndpointInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateRealtimeEndpointOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateRealtimeEndpointCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1CreateRealtimeEndpointCommand(input, context);
-    };
-    CreateRealtimeEndpointCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1CreateRealtimeEndpointCommand(output, context);
-    };
-    return CreateRealtimeEndpointCommand;
-}($Command));
-export { CreateRealtimeEndpointCommand };
+    }
+}

package/dist-es/commands/DeleteBatchPredictionCommand.js

@@ -1,39 +1,32 @@
-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";
-var DeleteBatchPredictionCommand = (function (_super) {
-    __extends(DeleteBatchPredictionCommand, _super);
-    function DeleteBatchPredictionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DeleteBatchPredictionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DeleteBatchPredictionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "DeleteBatchPredictionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "DeleteBatchPredictionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DeleteBatchPredictionInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteBatchPredictionOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DeleteBatchPredictionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1DeleteBatchPredictionCommand(input, context);
-    };
-    DeleteBatchPredictionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1DeleteBatchPredictionCommand(output, context);
-    };
-    return DeleteBatchPredictionCommand;
-}($Command));
-export { DeleteBatchPredictionCommand };
+    }
+}

package/dist-es/commands/DeleteDataSourceCommand.js

@@ -1,39 +1,32 @@
-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";
-var DeleteDataSourceCommand = (function (_super) {
-    __extends(DeleteDataSourceCommand, _super);
-    function DeleteDataSourceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DeleteDataSourceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DeleteDataSourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "MachineLearningClient";
-        var commandName = "DeleteDataSourceCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MachineLearningClient";
+        const commandName = "DeleteDataSourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DeleteDataSourceInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteDataSourceOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DeleteDataSourceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1DeleteDataSourceCommand(input, context);
-    };
-    DeleteDataSourceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1DeleteDataSourceCommand(output, context);
-    };
-    return DeleteDataSourceCommand;
-}($Command));
-export { DeleteDataSourceCommand };
+    }
+}