@aws-sdk/client-proton 3.34.0 → 3.37.0

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 { DeleteServiceInput, DeleteServiceOutput } from "../models/models_0";
+import { deserializeAws_json1_0DeleteServiceCommand, serializeAws_json1_0DeleteServiceCommand, } from "../protocols/Aws_json1_0";
+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 = "ProtonClient";
+        var commandName = "DeleteServiceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteServiceInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteServiceOutput.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_json1_0DeleteServiceCommand(input, context);
+    };
+    DeleteServiceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteServiceCommand(output, context);
+    };
+    return DeleteServiceCommand;
+}($Command));
+export { DeleteServiceCommand };

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

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

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

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

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 { GetEnvironmentInput, GetEnvironmentOutput } from "../models/models_0";
+import { deserializeAws_json1_0GetEnvironmentCommand, serializeAws_json1_0GetEnvironmentCommand, } from "../protocols/Aws_json1_0";
+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 = "ProtonClient";
+        var commandName = "GetEnvironmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetEnvironmentInput.filterSensitiveLog,
+            outputFilterSensitiveLog: GetEnvironmentOutput.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_json1_0GetEnvironmentCommand(input, context);
+    };
+    GetEnvironmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetEnvironmentCommand(output, context);
+    };
+    return GetEnvironmentCommand;
+}($Command));
+export { GetEnvironmentCommand };

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

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

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 { GetServiceInput, GetServiceOutput } from "../models/models_0";
+import { deserializeAws_json1_0GetServiceCommand, serializeAws_json1_0GetServiceCommand, } from "../protocols/Aws_json1_0";
+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 = "ProtonClient";
+        var commandName = "GetServiceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetServiceInput.filterSensitiveLog,
+            outputFilterSensitiveLog: GetServiceOutput.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_json1_0GetServiceCommand(input, context);
+    };
+    GetServiceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetServiceCommand(output, context);
+    };
+    return GetServiceCommand;
+}($Command));
+export { GetServiceCommand };

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

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

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

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

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

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

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 { ListEnvironmentsInput, ListEnvironmentsOutput } from "../models/models_0";
+import { deserializeAws_json1_0ListEnvironmentsCommand, serializeAws_json1_0ListEnvironmentsCommand, } from "../protocols/Aws_json1_0";
+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 = "ProtonClient";
+        var commandName = "ListEnvironmentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListEnvironmentsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListEnvironmentsOutput.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_json1_0ListEnvironmentsCommand(input, context);
+    };
+    ListEnvironmentsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListEnvironmentsCommand(output, context);
+    };
+    return ListEnvironmentsCommand;
+}($Command));
+export { ListEnvironmentsCommand };