@aws-sdk/client-proton 3.183.0 → 3.185.0

package/dist-es/commands/CreateEnvironmentTemplateVersionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateEnvironmentTemplateVersionInputFilterSensitiveLog, CreateEnvironmentTemplateVersionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateEnvironmentTemplateVersionCommand, serializeAws_json1_0CreateEnvironmentTemplateVersionCommand, } from "../protocols/Aws_json1_0";
-export class CreateEnvironmentTemplateVersionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateEnvironmentTemplateVersionCommand = (function (_super) {
+    __extends(CreateEnvironmentTemplateVersionCommand, _super);
+    function CreateEnvironmentTemplateVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateEnvironmentTemplateVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "CreateEnvironmentTemplateVersionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: CreateEnvironmentTemplateVersionInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateEnvironmentTemplateVersionOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    CreateEnvironmentTemplateVersionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateEnvironmentTemplateVersionCommand(output, context);
-    }
-}
+    };
+    return CreateEnvironmentTemplateVersionCommand;
+}($Command));
+export { CreateEnvironmentTemplateVersionCommand };

package/dist-es/commands/CreateRepositoryCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateRepositoryInputFilterSensitiveLog, CreateRepositoryOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateRepositoryCommand, serializeAws_json1_0CreateRepositoryCommand, } from "../protocols/Aws_json1_0";
-export class CreateRepositoryCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateRepositoryCommand = (function (_super) {
+    __extends(CreateRepositoryCommand, _super);
+    function CreateRepositoryCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateRepositoryCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "CreateRepositoryCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "CreateRepositoryCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateRepositoryInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateRepositoryOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateRepositoryCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0CreateRepositoryCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateRepositoryCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateRepositoryCommand(output, context);
-    }
-}
+    };
+    return CreateRepositoryCommand;
+}($Command));
+export { CreateRepositoryCommand };

package/dist-es/commands/CreateServiceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateServiceInputFilterSensitiveLog, CreateServiceOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateServiceCommand, serializeAws_json1_0CreateServiceCommand, } from "../protocols/Aws_json1_0";
-export class CreateServiceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateServiceCommand = (function (_super) {
+    __extends(CreateServiceCommand, _super);
+    function CreateServiceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateServiceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "CreateServiceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: CreateServiceInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateServiceOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    CreateServiceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateServiceCommand(output, context);
-    }
-}
+    };
+    return CreateServiceCommand;
+}($Command));
+export { CreateServiceCommand };

package/dist-es/commands/CreateServiceTemplateCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateServiceTemplateInputFilterSensitiveLog, CreateServiceTemplateOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateServiceTemplateCommand, serializeAws_json1_0CreateServiceTemplateCommand, } from "../protocols/Aws_json1_0";
-export class CreateServiceTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateServiceTemplateCommand = (function (_super) {
+    __extends(CreateServiceTemplateCommand, _super);
+    function CreateServiceTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateServiceTemplateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "CreateServiceTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: CreateServiceTemplateInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateServiceTemplateOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    CreateServiceTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateServiceTemplateCommand(output, context);
-    }
-}
+    };
+    return CreateServiceTemplateCommand;
+}($Command));
+export { CreateServiceTemplateCommand };

package/dist-es/commands/CreateServiceTemplateVersionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateServiceTemplateVersionInputFilterSensitiveLog, CreateServiceTemplateVersionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateServiceTemplateVersionCommand, serializeAws_json1_0CreateServiceTemplateVersionCommand, } from "../protocols/Aws_json1_0";
-export class CreateServiceTemplateVersionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateServiceTemplateVersionCommand = (function (_super) {
+    __extends(CreateServiceTemplateVersionCommand, _super);
+    function CreateServiceTemplateVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateServiceTemplateVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "CreateServiceTemplateVersionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: CreateServiceTemplateVersionInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateServiceTemplateVersionOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    CreateServiceTemplateVersionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateServiceTemplateVersionCommand(output, context);
-    }
-}
+    };
+    return CreateServiceTemplateVersionCommand;
+}($Command));
+export { CreateServiceTemplateVersionCommand };

package/dist-es/commands/CreateTemplateSyncConfigCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateTemplateSyncConfigInputFilterSensitiveLog, CreateTemplateSyncConfigOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0CreateTemplateSyncConfigCommand, serializeAws_json1_0CreateTemplateSyncConfigCommand, } from "../protocols/Aws_json1_0";
-export class CreateTemplateSyncConfigCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateTemplateSyncConfigCommand = (function (_super) {
+    __extends(CreateTemplateSyncConfigCommand, _super);
+    function CreateTemplateSyncConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateTemplateSyncConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "CreateTemplateSyncConfigCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "CreateTemplateSyncConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateTemplateSyncConfigInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateTemplateSyncConfigOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateTemplateSyncConfigCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0CreateTemplateSyncConfigCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateTemplateSyncConfigCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0CreateTemplateSyncConfigCommand(output, context);
-    }
-}
+    };
+    return CreateTemplateSyncConfigCommand;
+}($Command));
+export { CreateTemplateSyncConfigCommand };

package/dist-es/commands/DeleteComponentCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteComponentInputFilterSensitiveLog, DeleteComponentOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DeleteComponentCommand, serializeAws_json1_0DeleteComponentCommand, } from "../protocols/Aws_json1_0";
-export class DeleteComponentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteComponentCommand = (function (_super) {
+    __extends(DeleteComponentCommand, _super);
+    function DeleteComponentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteComponentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "DeleteComponentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "DeleteComponentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteComponentInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteComponentOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteComponentCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0DeleteComponentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteComponentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DeleteComponentCommand(output, context);
-    }
-}
+    };
+    return DeleteComponentCommand;
+}($Command));
+export { DeleteComponentCommand };

package/dist-es/commands/DeleteEnvironmentAccountConnectionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteEnvironmentAccountConnectionInputFilterSensitiveLog, DeleteEnvironmentAccountConnectionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DeleteEnvironmentAccountConnectionCommand, serializeAws_json1_0DeleteEnvironmentAccountConnectionCommand, } from "../protocols/Aws_json1_0";
-export class DeleteEnvironmentAccountConnectionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteEnvironmentAccountConnectionCommand = (function (_super) {
+    __extends(DeleteEnvironmentAccountConnectionCommand, _super);
+    function DeleteEnvironmentAccountConnectionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteEnvironmentAccountConnectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "DeleteEnvironmentAccountConnectionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DeleteEnvironmentAccountConnectionInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteEnvironmentAccountConnectionOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DeleteEnvironmentAccountConnectionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DeleteEnvironmentAccountConnectionCommand(output, context);
-    }
-}
+    };
+    return DeleteEnvironmentAccountConnectionCommand;
+}($Command));
+export { DeleteEnvironmentAccountConnectionCommand };

package/dist-es/commands/DeleteEnvironmentCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteEnvironmentInputFilterSensitiveLog, DeleteEnvironmentOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DeleteEnvironmentCommand, serializeAws_json1_0DeleteEnvironmentCommand, } from "../protocols/Aws_json1_0";
-export class DeleteEnvironmentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteEnvironmentCommand = (function (_super) {
+    __extends(DeleteEnvironmentCommand, _super);
+    function DeleteEnvironmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteEnvironmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "DeleteEnvironmentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DeleteEnvironmentInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteEnvironmentOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DeleteEnvironmentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DeleteEnvironmentCommand(output, context);
-    }
-}
+    };
+    return DeleteEnvironmentCommand;
+}($Command));
+export { DeleteEnvironmentCommand };

package/dist-es/commands/DeleteEnvironmentTemplateCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteEnvironmentTemplateInputFilterSensitiveLog, DeleteEnvironmentTemplateOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0DeleteEnvironmentTemplateCommand, serializeAws_json1_0DeleteEnvironmentTemplateCommand, } from "../protocols/Aws_json1_0";
-export class DeleteEnvironmentTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteEnvironmentTemplateCommand = (function (_super) {
+    __extends(DeleteEnvironmentTemplateCommand, _super);
+    function DeleteEnvironmentTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteEnvironmentTemplateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ProtonClient";
-        const commandName = "DeleteEnvironmentTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DeleteEnvironmentTemplateInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteEnvironmentTemplateOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DeleteEnvironmentTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0DeleteEnvironmentTemplateCommand(output, context);
-    }
-}
+    };
+    return DeleteEnvironmentTemplateCommand;
+}($Command));
+export { DeleteEnvironmentTemplateCommand };