@aws-sdk/client-proton 3.181.0 → 3.183.0

package/dist-es/Proton.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { AcceptEnvironmentAccountConnectionCommand, } from "./commands/AcceptEnvironmentAccountConnectionCommand";
 import { CancelComponentDeploymentCommand, } from "./commands/CancelComponentDeploymentCommand";
 import { CancelEnvironmentDeploymentCommand, } from "./commands/CancelEnvironmentDeploymentCommand";
@@ -75,1061 +74,1055 @@ import { UpdateServiceTemplateCommand, } from "./commands/UpdateServiceTemplateC
 import { UpdateServiceTemplateVersionCommand, } from "./commands/UpdateServiceTemplateVersionCommand";
 import { UpdateTemplateSyncConfigCommand, } from "./commands/UpdateTemplateSyncConfigCommand";
 import { ProtonClient } from "./ProtonClient";
-var Proton = (function (_super) {
-    __extends(Proton, _super);
-    function Proton() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Proton.prototype.acceptEnvironmentAccountConnection = function (args, optionsOrCb, cb) {
-        var command = new AcceptEnvironmentAccountConnectionCommand(args);
+export class Proton extends ProtonClient {
+    acceptEnvironmentAccountConnection(args, optionsOrCb, cb) {
+        const command = new AcceptEnvironmentAccountConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.cancelComponentDeployment = function (args, optionsOrCb, cb) {
-        var command = new CancelComponentDeploymentCommand(args);
+    }
+    cancelComponentDeployment(args, optionsOrCb, cb) {
+        const command = new CancelComponentDeploymentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.cancelEnvironmentDeployment = function (args, optionsOrCb, cb) {
-        var command = new CancelEnvironmentDeploymentCommand(args);
+    }
+    cancelEnvironmentDeployment(args, optionsOrCb, cb) {
+        const command = new CancelEnvironmentDeploymentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.cancelServiceInstanceDeployment = function (args, optionsOrCb, cb) {
-        var command = new CancelServiceInstanceDeploymentCommand(args);
+    }
+    cancelServiceInstanceDeployment(args, optionsOrCb, cb) {
+        const command = new CancelServiceInstanceDeploymentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.cancelServicePipelineDeployment = function (args, optionsOrCb, cb) {
-        var command = new CancelServicePipelineDeploymentCommand(args);
+    }
+    cancelServicePipelineDeployment(args, optionsOrCb, cb) {
+        const command = new CancelServicePipelineDeploymentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createComponent = function (args, optionsOrCb, cb) {
-        var command = new CreateComponentCommand(args);
+    }
+    createComponent(args, optionsOrCb, cb) {
+        const command = new CreateComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createEnvironment = function (args, optionsOrCb, cb) {
-        var command = new CreateEnvironmentCommand(args);
+    }
+    createEnvironment(args, optionsOrCb, cb) {
+        const command = new CreateEnvironmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createEnvironmentAccountConnection = function (args, optionsOrCb, cb) {
-        var command = new CreateEnvironmentAccountConnectionCommand(args);
+    }
+    createEnvironmentAccountConnection(args, optionsOrCb, cb) {
+        const command = new CreateEnvironmentAccountConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createEnvironmentTemplate = function (args, optionsOrCb, cb) {
-        var command = new CreateEnvironmentTemplateCommand(args);
+    }
+    createEnvironmentTemplate(args, optionsOrCb, cb) {
+        const command = new CreateEnvironmentTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createEnvironmentTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateEnvironmentTemplateVersionCommand(args);
+    }
+    createEnvironmentTemplateVersion(args, optionsOrCb, cb) {
+        const command = new CreateEnvironmentTemplateVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createRepository = function (args, optionsOrCb, cb) {
-        var command = new CreateRepositoryCommand(args);
+    }
+    createRepository(args, optionsOrCb, cb) {
+        const command = new CreateRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createService = function (args, optionsOrCb, cb) {
-        var command = new CreateServiceCommand(args);
+    }
+    createService(args, optionsOrCb, cb) {
+        const command = new CreateServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createServiceTemplate = function (args, optionsOrCb, cb) {
-        var command = new CreateServiceTemplateCommand(args);
+    }
+    createServiceTemplate(args, optionsOrCb, cb) {
+        const command = new CreateServiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createServiceTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateServiceTemplateVersionCommand(args);
+    }
+    createServiceTemplateVersion(args, optionsOrCb, cb) {
+        const command = new CreateServiceTemplateVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.createTemplateSyncConfig = function (args, optionsOrCb, cb) {
-        var command = new CreateTemplateSyncConfigCommand(args);
+    }
+    createTemplateSyncConfig(args, optionsOrCb, cb) {
+        const command = new CreateTemplateSyncConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteComponent = function (args, optionsOrCb, cb) {
-        var command = new DeleteComponentCommand(args);
+    }
+    deleteComponent(args, optionsOrCb, cb) {
+        const command = new DeleteComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteEnvironment = function (args, optionsOrCb, cb) {
-        var command = new DeleteEnvironmentCommand(args);
+    }
+    deleteEnvironment(args, optionsOrCb, cb) {
+        const command = new DeleteEnvironmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteEnvironmentAccountConnection = function (args, optionsOrCb, cb) {
-        var command = new DeleteEnvironmentAccountConnectionCommand(args);
+    }
+    deleteEnvironmentAccountConnection(args, optionsOrCb, cb) {
+        const command = new DeleteEnvironmentAccountConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteEnvironmentTemplate = function (args, optionsOrCb, cb) {
-        var command = new DeleteEnvironmentTemplateCommand(args);
+    }
+    deleteEnvironmentTemplate(args, optionsOrCb, cb) {
+        const command = new DeleteEnvironmentTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteEnvironmentTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new DeleteEnvironmentTemplateVersionCommand(args);
+    }
+    deleteEnvironmentTemplateVersion(args, optionsOrCb, cb) {
+        const command = new DeleteEnvironmentTemplateVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteRepository = function (args, optionsOrCb, cb) {
-        var command = new DeleteRepositoryCommand(args);
+    }
+    deleteRepository(args, optionsOrCb, cb) {
+        const command = new DeleteRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteService = function (args, optionsOrCb, cb) {
-        var command = new DeleteServiceCommand(args);
+    }
+    deleteService(args, optionsOrCb, cb) {
+        const command = new DeleteServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteServiceTemplate = function (args, optionsOrCb, cb) {
-        var command = new DeleteServiceTemplateCommand(args);
+    }
+    deleteServiceTemplate(args, optionsOrCb, cb) {
+        const command = new DeleteServiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteServiceTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new DeleteServiceTemplateVersionCommand(args);
+    }
+    deleteServiceTemplateVersion(args, optionsOrCb, cb) {
+        const command = new DeleteServiceTemplateVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.deleteTemplateSyncConfig = function (args, optionsOrCb, cb) {
-        var command = new DeleteTemplateSyncConfigCommand(args);
+    }
+    deleteTemplateSyncConfig(args, optionsOrCb, cb) {
+        const command = new DeleteTemplateSyncConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getAccountSettings = function (args, optionsOrCb, cb) {
-        var command = new GetAccountSettingsCommand(args);
+    }
+    getAccountSettings(args, optionsOrCb, cb) {
+        const command = new GetAccountSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getComponent = function (args, optionsOrCb, cb) {
-        var command = new GetComponentCommand(args);
+    }
+    getComponent(args, optionsOrCb, cb) {
+        const command = new GetComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getEnvironment = function (args, optionsOrCb, cb) {
-        var command = new GetEnvironmentCommand(args);
+    }
+    getEnvironment(args, optionsOrCb, cb) {
+        const command = new GetEnvironmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getEnvironmentAccountConnection = function (args, optionsOrCb, cb) {
-        var command = new GetEnvironmentAccountConnectionCommand(args);
+    }
+    getEnvironmentAccountConnection(args, optionsOrCb, cb) {
+        const command = new GetEnvironmentAccountConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getEnvironmentTemplate = function (args, optionsOrCb, cb) {
-        var command = new GetEnvironmentTemplateCommand(args);
+    }
+    getEnvironmentTemplate(args, optionsOrCb, cb) {
+        const command = new GetEnvironmentTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getEnvironmentTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new GetEnvironmentTemplateVersionCommand(args);
+    }
+    getEnvironmentTemplateVersion(args, optionsOrCb, cb) {
+        const command = new GetEnvironmentTemplateVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getRepository = function (args, optionsOrCb, cb) {
-        var command = new GetRepositoryCommand(args);
+    }
+    getRepository(args, optionsOrCb, cb) {
+        const command = new GetRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getRepositorySyncStatus = function (args, optionsOrCb, cb) {
-        var command = new GetRepositorySyncStatusCommand(args);
+    }
+    getRepositorySyncStatus(args, optionsOrCb, cb) {
+        const command = new GetRepositorySyncStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getService = function (args, optionsOrCb, cb) {
-        var command = new GetServiceCommand(args);
+    }
+    getService(args, optionsOrCb, cb) {
+        const command = new GetServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getServiceInstance = function (args, optionsOrCb, cb) {
-        var command = new GetServiceInstanceCommand(args);
+    }
+    getServiceInstance(args, optionsOrCb, cb) {
+        const command = new GetServiceInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getServiceTemplate = function (args, optionsOrCb, cb) {
-        var command = new GetServiceTemplateCommand(args);
+    }
+    getServiceTemplate(args, optionsOrCb, cb) {
+        const command = new GetServiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getServiceTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new GetServiceTemplateVersionCommand(args);
+    }
+    getServiceTemplateVersion(args, optionsOrCb, cb) {
+        const command = new GetServiceTemplateVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getTemplateSyncConfig = function (args, optionsOrCb, cb) {
-        var command = new GetTemplateSyncConfigCommand(args);
+    }
+    getTemplateSyncConfig(args, optionsOrCb, cb) {
+        const command = new GetTemplateSyncConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.getTemplateSyncStatus = function (args, optionsOrCb, cb) {
-        var command = new GetTemplateSyncStatusCommand(args);
+    }
+    getTemplateSyncStatus(args, optionsOrCb, cb) {
+        const command = new GetTemplateSyncStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listComponentOutputs = function (args, optionsOrCb, cb) {
-        var command = new ListComponentOutputsCommand(args);
+    }
+    listComponentOutputs(args, optionsOrCb, cb) {
+        const command = new ListComponentOutputsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listComponentProvisionedResources = function (args, optionsOrCb, cb) {
-        var command = new ListComponentProvisionedResourcesCommand(args);
+    }
+    listComponentProvisionedResources(args, optionsOrCb, cb) {
+        const command = new ListComponentProvisionedResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listComponents = function (args, optionsOrCb, cb) {
-        var command = new ListComponentsCommand(args);
+    }
+    listComponents(args, optionsOrCb, cb) {
+        const command = new ListComponentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listEnvironmentAccountConnections = function (args, optionsOrCb, cb) {
-        var command = new ListEnvironmentAccountConnectionsCommand(args);
+    }
+    listEnvironmentAccountConnections(args, optionsOrCb, cb) {
+        const command = new ListEnvironmentAccountConnectionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listEnvironmentOutputs = function (args, optionsOrCb, cb) {
-        var command = new ListEnvironmentOutputsCommand(args);
+    }
+    listEnvironmentOutputs(args, optionsOrCb, cb) {
+        const command = new ListEnvironmentOutputsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listEnvironmentProvisionedResources = function (args, optionsOrCb, cb) {
-        var command = new ListEnvironmentProvisionedResourcesCommand(args);
+    }
+    listEnvironmentProvisionedResources(args, optionsOrCb, cb) {
+        const command = new ListEnvironmentProvisionedResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listEnvironments = function (args, optionsOrCb, cb) {
-        var command = new ListEnvironmentsCommand(args);
+    }
+    listEnvironments(args, optionsOrCb, cb) {
+        const command = new ListEnvironmentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listEnvironmentTemplates = function (args, optionsOrCb, cb) {
-        var command = new ListEnvironmentTemplatesCommand(args);
+    }
+    listEnvironmentTemplates(args, optionsOrCb, cb) {
+        const command = new ListEnvironmentTemplatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listEnvironmentTemplateVersions = function (args, optionsOrCb, cb) {
-        var command = new ListEnvironmentTemplateVersionsCommand(args);
+    }
+    listEnvironmentTemplateVersions(args, optionsOrCb, cb) {
+        const command = new ListEnvironmentTemplateVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listRepositories = function (args, optionsOrCb, cb) {
-        var command = new ListRepositoriesCommand(args);
+    }
+    listRepositories(args, optionsOrCb, cb) {
+        const command = new ListRepositoriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listRepositorySyncDefinitions = function (args, optionsOrCb, cb) {
-        var command = new ListRepositorySyncDefinitionsCommand(args);
+    }
+    listRepositorySyncDefinitions(args, optionsOrCb, cb) {
+        const command = new ListRepositorySyncDefinitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listServiceInstanceOutputs = function (args, optionsOrCb, cb) {
-        var command = new ListServiceInstanceOutputsCommand(args);
+    }
+    listServiceInstanceOutputs(args, optionsOrCb, cb) {
+        const command = new ListServiceInstanceOutputsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listServiceInstanceProvisionedResources = function (args, optionsOrCb, cb) {
-        var command = new ListServiceInstanceProvisionedResourcesCommand(args);
+    }
+    listServiceInstanceProvisionedResources(args, optionsOrCb, cb) {
+        const command = new ListServiceInstanceProvisionedResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listServiceInstances = function (args, optionsOrCb, cb) {
-        var command = new ListServiceInstancesCommand(args);
+    }
+    listServiceInstances(args, optionsOrCb, cb) {
+        const command = new ListServiceInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listServicePipelineOutputs = function (args, optionsOrCb, cb) {
-        var command = new ListServicePipelineOutputsCommand(args);
+    }
+    listServicePipelineOutputs(args, optionsOrCb, cb) {
+        const command = new ListServicePipelineOutputsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listServicePipelineProvisionedResources = function (args, optionsOrCb, cb) {
-        var command = new ListServicePipelineProvisionedResourcesCommand(args);
+    }
+    listServicePipelineProvisionedResources(args, optionsOrCb, cb) {
+        const command = new ListServicePipelineProvisionedResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listServices = function (args, optionsOrCb, cb) {
-        var command = new ListServicesCommand(args);
+    }
+    listServices(args, optionsOrCb, cb) {
+        const command = new ListServicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listServiceTemplates = function (args, optionsOrCb, cb) {
-        var command = new ListServiceTemplatesCommand(args);
+    }
+    listServiceTemplates(args, optionsOrCb, cb) {
+        const command = new ListServiceTemplatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listServiceTemplateVersions = function (args, optionsOrCb, cb) {
-        var command = new ListServiceTemplateVersionsCommand(args);
+    }
+    listServiceTemplateVersions(args, optionsOrCb, cb) {
+        const command = new ListServiceTemplateVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.notifyResourceDeploymentStatusChange = function (args, optionsOrCb, cb) {
-        var command = new NotifyResourceDeploymentStatusChangeCommand(args);
+    }
+    notifyResourceDeploymentStatusChange(args, optionsOrCb, cb) {
+        const command = new NotifyResourceDeploymentStatusChangeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.rejectEnvironmentAccountConnection = function (args, optionsOrCb, cb) {
-        var command = new RejectEnvironmentAccountConnectionCommand(args);
+    }
+    rejectEnvironmentAccountConnection(args, optionsOrCb, cb) {
+        const command = new RejectEnvironmentAccountConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateAccountSettings = function (args, optionsOrCb, cb) {
-        var command = new UpdateAccountSettingsCommand(args);
+    }
+    updateAccountSettings(args, optionsOrCb, cb) {
+        const command = new UpdateAccountSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateComponent = function (args, optionsOrCb, cb) {
-        var command = new UpdateComponentCommand(args);
+    }
+    updateComponent(args, optionsOrCb, cb) {
+        const command = new UpdateComponentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateEnvironment = function (args, optionsOrCb, cb) {
-        var command = new UpdateEnvironmentCommand(args);
+    }
+    updateEnvironment(args, optionsOrCb, cb) {
+        const command = new UpdateEnvironmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateEnvironmentAccountConnection = function (args, optionsOrCb, cb) {
-        var command = new UpdateEnvironmentAccountConnectionCommand(args);
+    }
+    updateEnvironmentAccountConnection(args, optionsOrCb, cb) {
+        const command = new UpdateEnvironmentAccountConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateEnvironmentTemplate = function (args, optionsOrCb, cb) {
-        var command = new UpdateEnvironmentTemplateCommand(args);
+    }
+    updateEnvironmentTemplate(args, optionsOrCb, cb) {
+        const command = new UpdateEnvironmentTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateEnvironmentTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new UpdateEnvironmentTemplateVersionCommand(args);
+    }
+    updateEnvironmentTemplateVersion(args, optionsOrCb, cb) {
+        const command = new UpdateEnvironmentTemplateVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateService = function (args, optionsOrCb, cb) {
-        var command = new UpdateServiceCommand(args);
+    }
+    updateService(args, optionsOrCb, cb) {
+        const command = new UpdateServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateServiceInstance = function (args, optionsOrCb, cb) {
-        var command = new UpdateServiceInstanceCommand(args);
+    }
+    updateServiceInstance(args, optionsOrCb, cb) {
+        const command = new UpdateServiceInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateServicePipeline = function (args, optionsOrCb, cb) {
-        var command = new UpdateServicePipelineCommand(args);
+    }
+    updateServicePipeline(args, optionsOrCb, cb) {
+        const command = new UpdateServicePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateServiceTemplate = function (args, optionsOrCb, cb) {
-        var command = new UpdateServiceTemplateCommand(args);
+    }
+    updateServiceTemplate(args, optionsOrCb, cb) {
+        const command = new UpdateServiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateServiceTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new UpdateServiceTemplateVersionCommand(args);
+    }
+    updateServiceTemplateVersion(args, optionsOrCb, cb) {
+        const command = new UpdateServiceTemplateVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Proton.prototype.updateTemplateSyncConfig = function (args, optionsOrCb, cb) {
-        var command = new UpdateTemplateSyncConfigCommand(args);
+    }
+    updateTemplateSyncConfig(args, optionsOrCb, cb) {
+        const command = new UpdateTemplateSyncConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return Proton;
-}(ProtonClient));
-export { Proton };
+    }
+}