@aws-sdk/client-m2 3.107.0

package/dist-es/commands/CancelBatchJobExecutionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CancelBatchJobExecutionRequest, CancelBatchJobExecutionResponse } from "../models/models_0";
+import { deserializeAws_restJson1CancelBatchJobExecutionCommand, serializeAws_restJson1CancelBatchJobExecutionCommand, } from "../protocols/Aws_restJson1";
+var CancelBatchJobExecutionCommand = (function (_super) {
+    __extends(CancelBatchJobExecutionCommand, _super);
+    function CancelBatchJobExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CancelBatchJobExecutionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "CancelBatchJobExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CancelBatchJobExecutionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CancelBatchJobExecutionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CancelBatchJobExecutionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CancelBatchJobExecutionCommand(input, context);
+    };
+    CancelBatchJobExecutionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CancelBatchJobExecutionCommand(output, context);
+    };
+    return CancelBatchJobExecutionCommand;
+}($Command));
+export { CancelBatchJobExecutionCommand };

package/dist-es/commands/CreateApplicationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateApplicationRequest, CreateApplicationResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateApplicationCommand, serializeAws_restJson1CreateApplicationCommand, } from "../protocols/Aws_restJson1";
+var CreateApplicationCommand = (function (_super) {
+    __extends(CreateApplicationCommand, _super);
+    function CreateApplicationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateApplicationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "CreateApplicationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateApplicationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateApplicationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateApplicationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateApplicationCommand(input, context);
+    };
+    CreateApplicationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateApplicationCommand(output, context);
+    };
+    return CreateApplicationCommand;
+}($Command));
+export { CreateApplicationCommand };

package/dist-es/commands/CreateDataSetImportTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDataSetImportTaskRequest, CreateDataSetImportTaskResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateDataSetImportTaskCommand, serializeAws_restJson1CreateDataSetImportTaskCommand, } from "../protocols/Aws_restJson1";
+var CreateDataSetImportTaskCommand = (function (_super) {
+    __extends(CreateDataSetImportTaskCommand, _super);
+    function CreateDataSetImportTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDataSetImportTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "CreateDataSetImportTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDataSetImportTaskRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDataSetImportTaskResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDataSetImportTaskCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateDataSetImportTaskCommand(input, context);
+    };
+    CreateDataSetImportTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateDataSetImportTaskCommand(output, context);
+    };
+    return CreateDataSetImportTaskCommand;
+}($Command));
+export { CreateDataSetImportTaskCommand };

package/dist-es/commands/CreateDeploymentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDeploymentRequest, CreateDeploymentResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateDeploymentCommand, serializeAws_restJson1CreateDeploymentCommand, } from "../protocols/Aws_restJson1";
+var CreateDeploymentCommand = (function (_super) {
+    __extends(CreateDeploymentCommand, _super);
+    function CreateDeploymentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDeploymentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "CreateDeploymentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDeploymentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDeploymentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDeploymentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateDeploymentCommand(input, context);
+    };
+    CreateDeploymentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateDeploymentCommand(output, context);
+    };
+    return CreateDeploymentCommand;
+}($Command));
+export { CreateDeploymentCommand };

package/dist-es/commands/CreateEnvironmentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateEnvironmentRequest, CreateEnvironmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateEnvironmentCommand, serializeAws_restJson1CreateEnvironmentCommand, } from "../protocols/Aws_restJson1";
+var CreateEnvironmentCommand = (function (_super) {
+    __extends(CreateEnvironmentCommand, _super);
+    function CreateEnvironmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateEnvironmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "CreateEnvironmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateEnvironmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateEnvironmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateEnvironmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateEnvironmentCommand(input, context);
+    };
+    CreateEnvironmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateEnvironmentCommand(output, context);
+    };
+    return CreateEnvironmentCommand;
+}($Command));
+export { CreateEnvironmentCommand };

package/dist-es/commands/DeleteApplicationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteApplicationRequest, DeleteApplicationResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteApplicationCommand, serializeAws_restJson1DeleteApplicationCommand, } from "../protocols/Aws_restJson1";
+var DeleteApplicationCommand = (function (_super) {
+    __extends(DeleteApplicationCommand, _super);
+    function DeleteApplicationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteApplicationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "DeleteApplicationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteApplicationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteApplicationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteApplicationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteApplicationCommand(input, context);
+    };
+    DeleteApplicationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteApplicationCommand(output, context);
+    };
+    return DeleteApplicationCommand;
+}($Command));
+export { DeleteApplicationCommand };

package/dist-es/commands/DeleteApplicationFromEnvironmentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteApplicationFromEnvironmentRequest, DeleteApplicationFromEnvironmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteApplicationFromEnvironmentCommand, serializeAws_restJson1DeleteApplicationFromEnvironmentCommand, } from "../protocols/Aws_restJson1";
+var DeleteApplicationFromEnvironmentCommand = (function (_super) {
+    __extends(DeleteApplicationFromEnvironmentCommand, _super);
+    function DeleteApplicationFromEnvironmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteApplicationFromEnvironmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "DeleteApplicationFromEnvironmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteApplicationFromEnvironmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteApplicationFromEnvironmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteApplicationFromEnvironmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteApplicationFromEnvironmentCommand(input, context);
+    };
+    DeleteApplicationFromEnvironmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteApplicationFromEnvironmentCommand(output, context);
+    };
+    return DeleteApplicationFromEnvironmentCommand;
+}($Command));
+export { DeleteApplicationFromEnvironmentCommand };

package/dist-es/commands/DeleteEnvironmentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteEnvironmentRequest, DeleteEnvironmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteEnvironmentCommand, serializeAws_restJson1DeleteEnvironmentCommand, } from "../protocols/Aws_restJson1";
+var DeleteEnvironmentCommand = (function (_super) {
+    __extends(DeleteEnvironmentCommand, _super);
+    function DeleteEnvironmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteEnvironmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "DeleteEnvironmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteEnvironmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteEnvironmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteEnvironmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteEnvironmentCommand(input, context);
+    };
+    DeleteEnvironmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteEnvironmentCommand(output, context);
+    };
+    return DeleteEnvironmentCommand;
+}($Command));
+export { DeleteEnvironmentCommand };

package/dist-es/commands/GetApplicationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetApplicationRequest, GetApplicationResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetApplicationCommand, serializeAws_restJson1GetApplicationCommand, } from "../protocols/Aws_restJson1";
+var GetApplicationCommand = (function (_super) {
+    __extends(GetApplicationCommand, _super);
+    function GetApplicationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetApplicationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "GetApplicationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetApplicationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetApplicationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetApplicationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetApplicationCommand(input, context);
+    };
+    GetApplicationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetApplicationCommand(output, context);
+    };
+    return GetApplicationCommand;
+}($Command));
+export { GetApplicationCommand };

package/dist-es/commands/GetApplicationVersionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetApplicationVersionRequest, GetApplicationVersionResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetApplicationVersionCommand, serializeAws_restJson1GetApplicationVersionCommand, } from "../protocols/Aws_restJson1";
+var GetApplicationVersionCommand = (function (_super) {
+    __extends(GetApplicationVersionCommand, _super);
+    function GetApplicationVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetApplicationVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "GetApplicationVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetApplicationVersionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetApplicationVersionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetApplicationVersionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetApplicationVersionCommand(input, context);
+    };
+    GetApplicationVersionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetApplicationVersionCommand(output, context);
+    };
+    return GetApplicationVersionCommand;
+}($Command));
+export { GetApplicationVersionCommand };

package/dist-es/commands/GetBatchJobExecutionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetBatchJobExecutionRequest, GetBatchJobExecutionResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetBatchJobExecutionCommand, serializeAws_restJson1GetBatchJobExecutionCommand, } from "../protocols/Aws_restJson1";
+var GetBatchJobExecutionCommand = (function (_super) {
+    __extends(GetBatchJobExecutionCommand, _super);
+    function GetBatchJobExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetBatchJobExecutionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "GetBatchJobExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetBatchJobExecutionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetBatchJobExecutionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetBatchJobExecutionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetBatchJobExecutionCommand(input, context);
+    };
+    GetBatchJobExecutionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetBatchJobExecutionCommand(output, context);
+    };
+    return GetBatchJobExecutionCommand;
+}($Command));
+export { GetBatchJobExecutionCommand };

package/dist-es/commands/GetDataSetDetailsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetDataSetDetailsRequest, GetDataSetDetailsResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetDataSetDetailsCommand, serializeAws_restJson1GetDataSetDetailsCommand, } from "../protocols/Aws_restJson1";
+var GetDataSetDetailsCommand = (function (_super) {
+    __extends(GetDataSetDetailsCommand, _super);
+    function GetDataSetDetailsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetDataSetDetailsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "GetDataSetDetailsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetDataSetDetailsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetDataSetDetailsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDataSetDetailsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetDataSetDetailsCommand(input, context);
+    };
+    GetDataSetDetailsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetDataSetDetailsCommand(output, context);
+    };
+    return GetDataSetDetailsCommand;
+}($Command));
+export { GetDataSetDetailsCommand };

package/dist-es/commands/GetDataSetImportTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetDataSetImportTaskRequest, GetDataSetImportTaskResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetDataSetImportTaskCommand, serializeAws_restJson1GetDataSetImportTaskCommand, } from "../protocols/Aws_restJson1";
+var GetDataSetImportTaskCommand = (function (_super) {
+    __extends(GetDataSetImportTaskCommand, _super);
+    function GetDataSetImportTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetDataSetImportTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "GetDataSetImportTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetDataSetImportTaskRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetDataSetImportTaskResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDataSetImportTaskCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetDataSetImportTaskCommand(input, context);
+    };
+    GetDataSetImportTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetDataSetImportTaskCommand(output, context);
+    };
+    return GetDataSetImportTaskCommand;
+}($Command));
+export { GetDataSetImportTaskCommand };

package/dist-es/commands/GetDeploymentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetDeploymentRequest, GetDeploymentResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetDeploymentCommand, serializeAws_restJson1GetDeploymentCommand, } from "../protocols/Aws_restJson1";
+var GetDeploymentCommand = (function (_super) {
+    __extends(GetDeploymentCommand, _super);
+    function GetDeploymentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetDeploymentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "GetDeploymentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetDeploymentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetDeploymentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDeploymentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetDeploymentCommand(input, context);
+    };
+    GetDeploymentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetDeploymentCommand(output, context);
+    };
+    return GetDeploymentCommand;
+}($Command));
+export { GetDeploymentCommand };

package/dist-es/commands/GetEnvironmentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetEnvironmentRequest, GetEnvironmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetEnvironmentCommand, serializeAws_restJson1GetEnvironmentCommand, } from "../protocols/Aws_restJson1";
+var GetEnvironmentCommand = (function (_super) {
+    __extends(GetEnvironmentCommand, _super);
+    function GetEnvironmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetEnvironmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "GetEnvironmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetEnvironmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetEnvironmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetEnvironmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetEnvironmentCommand(input, context);
+    };
+    GetEnvironmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetEnvironmentCommand(output, context);
+    };
+    return GetEnvironmentCommand;
+}($Command));
+export { GetEnvironmentCommand };

package/dist-es/commands/ListApplicationVersionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListApplicationVersionsRequest, ListApplicationVersionsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListApplicationVersionsCommand, serializeAws_restJson1ListApplicationVersionsCommand, } from "../protocols/Aws_restJson1";
+var ListApplicationVersionsCommand = (function (_super) {
+    __extends(ListApplicationVersionsCommand, _super);
+    function ListApplicationVersionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListApplicationVersionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "M2Client";
+        var commandName = "ListApplicationVersionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListApplicationVersionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListApplicationVersionsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListApplicationVersionsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListApplicationVersionsCommand(input, context);
+    };
+    ListApplicationVersionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListApplicationVersionsCommand(output, context);
+    };
+    return ListApplicationVersionsCommand;
+}($Command));
+export { ListApplicationVersionsCommand };