@aws-sdk/client-proton 3.183.0 → 3.185.0

package/dist-es/Proton.js

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