@aws-sdk/client-proton 3.34.0 → 3.37.0

package/dist-es/ProtonClient.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var ProtonClient = (function (_super) {
+    __extends(ProtonClient, _super);
+    function ProtonClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    ProtonClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return ProtonClient;
+}(__Client));
+export { ProtonClient };

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

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

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

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

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

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 { CreateEnvironmentInput, CreateEnvironmentOutput } from "../models/models_0";
+import { deserializeAws_json1_0CreateEnvironmentCommand, serializeAws_json1_0CreateEnvironmentCommand, } from "../protocols/Aws_json1_0";
+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 = "ProtonClient";
+        var commandName = "CreateEnvironmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateEnvironmentInput.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateEnvironmentOutput.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_json1_0CreateEnvironmentCommand(input, context);
+    };
+    CreateEnvironmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateEnvironmentCommand(output, context);
+    };
+    return CreateEnvironmentCommand;
+}($Command));
+export { CreateEnvironmentCommand };

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

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

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 { CreateServiceInput, CreateServiceOutput } from "../models/models_0";
+import { deserializeAws_json1_0CreateServiceCommand, serializeAws_json1_0CreateServiceCommand, } from "../protocols/Aws_json1_0";
+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 = "ProtonClient";
+        var commandName = "CreateServiceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateServiceInput.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateServiceOutput.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_json1_0CreateServiceCommand(input, context);
+    };
+    CreateServiceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateServiceCommand(output, context);
+    };
+    return CreateServiceCommand;
+}($Command));
+export { CreateServiceCommand };

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

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

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

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 { DeleteEnvironmentInput, DeleteEnvironmentOutput } from "../models/models_0";
+import { deserializeAws_json1_0DeleteEnvironmentCommand, serializeAws_json1_0DeleteEnvironmentCommand, } from "../protocols/Aws_json1_0";
+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 = "ProtonClient";
+        var commandName = "DeleteEnvironmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteEnvironmentInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteEnvironmentOutput.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_json1_0DeleteEnvironmentCommand(input, context);
+    };
+    DeleteEnvironmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteEnvironmentCommand(output, context);
+    };
+    return DeleteEnvironmentCommand;
+}($Command));
+export { DeleteEnvironmentCommand };

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

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