@aws-sdk/client-migration-hub-refactor-spaces 3.43.0

package/dist-es/commands/CreateServiceCommand.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 { CreateServiceRequest, CreateServiceResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateServiceCommand, serializeAws_restJson1CreateServiceCommand, } from "../protocols/Aws_restJson1";
+var CreateServiceCommand = (function (_super) {
+    __extends(CreateServiceCommand, _super);
+    function CreateServiceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateServiceCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "CreateServiceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateServiceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateServiceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateServiceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateServiceCommand(input, context);
+    };
+    CreateServiceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateServiceCommand(output, context);
+    };
+    return CreateServiceCommand;
+}($Command));
+export { CreateServiceCommand };

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 = "MigrationHubRefactorSpacesClient";
+        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/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 = "MigrationHubRefactorSpacesClient";
+        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/DeleteResourcePolicyCommand.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 { DeleteResourcePolicyRequest, DeleteResourcePolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteResourcePolicyCommand, serializeAws_restJson1DeleteResourcePolicyCommand, } from "../protocols/Aws_restJson1";
+var DeleteResourcePolicyCommand = (function (_super) {
+    __extends(DeleteResourcePolicyCommand, _super);
+    function DeleteResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteResourcePolicyCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "DeleteResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteResourcePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteResourcePolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteResourcePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteResourcePolicyCommand(input, context);
+    };
+    DeleteResourcePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteResourcePolicyCommand(output, context);
+    };
+    return DeleteResourcePolicyCommand;
+}($Command));
+export { DeleteResourcePolicyCommand };

package/dist-es/commands/DeleteRouteCommand.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 { DeleteRouteRequest, DeleteRouteResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteRouteCommand, serializeAws_restJson1DeleteRouteCommand, } from "../protocols/Aws_restJson1";
+var DeleteRouteCommand = (function (_super) {
+    __extends(DeleteRouteCommand, _super);
+    function DeleteRouteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteRouteCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "DeleteRouteCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteRouteRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteRouteResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteRouteCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteRouteCommand(input, context);
+    };
+    DeleteRouteCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteRouteCommand(output, context);
+    };
+    return DeleteRouteCommand;
+}($Command));
+export { DeleteRouteCommand };

package/dist-es/commands/DeleteServiceCommand.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 { DeleteServiceRequest, DeleteServiceResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteServiceCommand, serializeAws_restJson1DeleteServiceCommand, } from "../protocols/Aws_restJson1";
+var DeleteServiceCommand = (function (_super) {
+    __extends(DeleteServiceCommand, _super);
+    function DeleteServiceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteServiceCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "DeleteServiceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteServiceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteServiceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteServiceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteServiceCommand(input, context);
+    };
+    DeleteServiceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteServiceCommand(output, context);
+    };
+    return DeleteServiceCommand;
+}($Command));
+export { DeleteServiceCommand };

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 = "MigrationHubRefactorSpacesClient";
+        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/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 = "MigrationHubRefactorSpacesClient";
+        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/GetResourcePolicyCommand.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 { GetResourcePolicyRequest, GetResourcePolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetResourcePolicyCommand, serializeAws_restJson1GetResourcePolicyCommand, } from "../protocols/Aws_restJson1";
+var GetResourcePolicyCommand = (function (_super) {
+    __extends(GetResourcePolicyCommand, _super);
+    function GetResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResourcePolicyCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "GetResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResourcePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResourcePolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResourcePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetResourcePolicyCommand(input, context);
+    };
+    GetResourcePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetResourcePolicyCommand(output, context);
+    };
+    return GetResourcePolicyCommand;
+}($Command));
+export { GetResourcePolicyCommand };

package/dist-es/commands/GetRouteCommand.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 { GetRouteRequest, GetRouteResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetRouteCommand, serializeAws_restJson1GetRouteCommand, } from "../protocols/Aws_restJson1";
+var GetRouteCommand = (function (_super) {
+    __extends(GetRouteCommand, _super);
+    function GetRouteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetRouteCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "GetRouteCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetRouteRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetRouteResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRouteCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetRouteCommand(input, context);
+    };
+    GetRouteCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetRouteCommand(output, context);
+    };
+    return GetRouteCommand;
+}($Command));
+export { GetRouteCommand };

package/dist-es/commands/GetServiceCommand.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 { GetServiceRequest, GetServiceResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetServiceCommand, serializeAws_restJson1GetServiceCommand, } from "../protocols/Aws_restJson1";
+var GetServiceCommand = (function (_super) {
+    __extends(GetServiceCommand, _super);
+    function GetServiceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetServiceCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "GetServiceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetServiceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetServiceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetServiceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetServiceCommand(input, context);
+    };
+    GetServiceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetServiceCommand(output, context);
+    };
+    return GetServiceCommand;
+}($Command));
+export { GetServiceCommand };

package/dist-es/commands/ListApplicationsCommand.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 { ListApplicationsRequest, ListApplicationsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListApplicationsCommand, serializeAws_restJson1ListApplicationsCommand, } from "../protocols/Aws_restJson1";
+var ListApplicationsCommand = (function (_super) {
+    __extends(ListApplicationsCommand, _super);
+    function ListApplicationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListApplicationsCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "ListApplicationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListApplicationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListApplicationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListApplicationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListApplicationsCommand(input, context);
+    };
+    ListApplicationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListApplicationsCommand(output, context);
+    };
+    return ListApplicationsCommand;
+}($Command));
+export { ListApplicationsCommand };

package/dist-es/commands/ListEnvironmentVpcsCommand.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 { ListEnvironmentVpcsRequest, ListEnvironmentVpcsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListEnvironmentVpcsCommand, serializeAws_restJson1ListEnvironmentVpcsCommand, } from "../protocols/Aws_restJson1";
+var ListEnvironmentVpcsCommand = (function (_super) {
+    __extends(ListEnvironmentVpcsCommand, _super);
+    function ListEnvironmentVpcsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListEnvironmentVpcsCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "ListEnvironmentVpcsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListEnvironmentVpcsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListEnvironmentVpcsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListEnvironmentVpcsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListEnvironmentVpcsCommand(input, context);
+    };
+    ListEnvironmentVpcsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListEnvironmentVpcsCommand(output, context);
+    };
+    return ListEnvironmentVpcsCommand;
+}($Command));
+export { ListEnvironmentVpcsCommand };

package/dist-es/commands/ListEnvironmentsCommand.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 { ListEnvironmentsRequest, ListEnvironmentsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListEnvironmentsCommand, serializeAws_restJson1ListEnvironmentsCommand, } from "../protocols/Aws_restJson1";
+var ListEnvironmentsCommand = (function (_super) {
+    __extends(ListEnvironmentsCommand, _super);
+    function ListEnvironmentsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListEnvironmentsCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "ListEnvironmentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListEnvironmentsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListEnvironmentsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListEnvironmentsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListEnvironmentsCommand(input, context);
+    };
+    ListEnvironmentsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListEnvironmentsCommand(output, context);
+    };
+    return ListEnvironmentsCommand;
+}($Command));
+export { ListEnvironmentsCommand };

package/dist-es/commands/ListRoutesCommand.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 { ListRoutesRequest, ListRoutesResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListRoutesCommand, serializeAws_restJson1ListRoutesCommand, } from "../protocols/Aws_restJson1";
+var ListRoutesCommand = (function (_super) {
+    __extends(ListRoutesCommand, _super);
+    function ListRoutesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRoutesCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "ListRoutesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRoutesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListRoutesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRoutesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListRoutesCommand(input, context);
+    };
+    ListRoutesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListRoutesCommand(output, context);
+    };
+    return ListRoutesCommand;
+}($Command));
+export { ListRoutesCommand };

package/dist-es/commands/ListServicesCommand.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 { ListServicesRequest, ListServicesResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListServicesCommand, serializeAws_restJson1ListServicesCommand, } from "../protocols/Aws_restJson1";
+var ListServicesCommand = (function (_super) {
+    __extends(ListServicesCommand, _super);
+    function ListServicesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListServicesCommand.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 = "MigrationHubRefactorSpacesClient";
+        var commandName = "ListServicesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListServicesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListServicesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListServicesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListServicesCommand(input, context);
+    };
+    ListServicesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListServicesCommand(output, context);
+    };
+    return ListServicesCommand;
+}($Command));
+export { ListServicesCommand };