@aws-sdk/client-greengrass 3.185.0 → 3.188.0

package/dist-es/Greengrass.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { AssociateRoleToGroupCommand, } from "./commands/AssociateRoleToGroupCommand";
 import { AssociateServiceRoleToAccountCommand, } from "./commands/AssociateServiceRoleToAccountCommand";
 import { CreateConnectorDefinitionCommand, } from "./commands/CreateConnectorDefinitionCommand";
@@ -92,1299 +91,1293 @@ import { UpdateResourceDefinitionCommand, } from "./commands/UpdateResourceDefin
 import { UpdateSubscriptionDefinitionCommand, } from "./commands/UpdateSubscriptionDefinitionCommand";
 import { UpdateThingRuntimeConfigurationCommand, } from "./commands/UpdateThingRuntimeConfigurationCommand";
 import { GreengrassClient } from "./GreengrassClient";
-var Greengrass = (function (_super) {
-    __extends(Greengrass, _super);
-    function Greengrass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Greengrass.prototype.associateRoleToGroup = function (args, optionsOrCb, cb) {
-        var command = new AssociateRoleToGroupCommand(args);
+export class Greengrass extends GreengrassClient {
+    associateRoleToGroup(args, optionsOrCb, cb) {
+        const command = new AssociateRoleToGroupCommand(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);
         }
-    };
-    Greengrass.prototype.associateServiceRoleToAccount = function (args, optionsOrCb, cb) {
-        var command = new AssociateServiceRoleToAccountCommand(args);
+    }
+    associateServiceRoleToAccount(args, optionsOrCb, cb) {
+        const command = new AssociateServiceRoleToAccountCommand(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);
         }
-    };
-    Greengrass.prototype.createConnectorDefinition = function (args, optionsOrCb, cb) {
-        var command = new CreateConnectorDefinitionCommand(args);
+    }
+    createConnectorDefinition(args, optionsOrCb, cb) {
+        const command = new CreateConnectorDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.createConnectorDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateConnectorDefinitionVersionCommand(args);
+    }
+    createConnectorDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new CreateConnectorDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.createCoreDefinition = function (args, optionsOrCb, cb) {
-        var command = new CreateCoreDefinitionCommand(args);
+    }
+    createCoreDefinition(args, optionsOrCb, cb) {
+        const command = new CreateCoreDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.createCoreDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateCoreDefinitionVersionCommand(args);
+    }
+    createCoreDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new CreateCoreDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.createDeployment = function (args, optionsOrCb, cb) {
-        var command = new CreateDeploymentCommand(args);
+    }
+    createDeployment(args, optionsOrCb, cb) {
+        const command = new CreateDeploymentCommand(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);
         }
-    };
-    Greengrass.prototype.createDeviceDefinition = function (args, optionsOrCb, cb) {
-        var command = new CreateDeviceDefinitionCommand(args);
+    }
+    createDeviceDefinition(args, optionsOrCb, cb) {
+        const command = new CreateDeviceDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.createDeviceDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateDeviceDefinitionVersionCommand(args);
+    }
+    createDeviceDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new CreateDeviceDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.createFunctionDefinition = function (args, optionsOrCb, cb) {
-        var command = new CreateFunctionDefinitionCommand(args);
+    }
+    createFunctionDefinition(args, optionsOrCb, cb) {
+        const command = new CreateFunctionDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.createFunctionDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateFunctionDefinitionVersionCommand(args);
+    }
+    createFunctionDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new CreateFunctionDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.createGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateGroupCommand(args);
+    }
+    createGroup(args, optionsOrCb, cb) {
+        const command = new CreateGroupCommand(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);
         }
-    };
-    Greengrass.prototype.createGroupCertificateAuthority = function (args, optionsOrCb, cb) {
-        var command = new CreateGroupCertificateAuthorityCommand(args);
+    }
+    createGroupCertificateAuthority(args, optionsOrCb, cb) {
+        const command = new CreateGroupCertificateAuthorityCommand(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);
         }
-    };
-    Greengrass.prototype.createGroupVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateGroupVersionCommand(args);
+    }
+    createGroupVersion(args, optionsOrCb, cb) {
+        const command = new CreateGroupVersionCommand(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);
         }
-    };
-    Greengrass.prototype.createLoggerDefinition = function (args, optionsOrCb, cb) {
-        var command = new CreateLoggerDefinitionCommand(args);
+    }
+    createLoggerDefinition(args, optionsOrCb, cb) {
+        const command = new CreateLoggerDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.createLoggerDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateLoggerDefinitionVersionCommand(args);
+    }
+    createLoggerDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new CreateLoggerDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.createResourceDefinition = function (args, optionsOrCb, cb) {
-        var command = new CreateResourceDefinitionCommand(args);
+    }
+    createResourceDefinition(args, optionsOrCb, cb) {
+        const command = new CreateResourceDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.createResourceDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateResourceDefinitionVersionCommand(args);
+    }
+    createResourceDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new CreateResourceDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.createSoftwareUpdateJob = function (args, optionsOrCb, cb) {
-        var command = new CreateSoftwareUpdateJobCommand(args);
+    }
+    createSoftwareUpdateJob(args, optionsOrCb, cb) {
+        const command = new CreateSoftwareUpdateJobCommand(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);
         }
-    };
-    Greengrass.prototype.createSubscriptionDefinition = function (args, optionsOrCb, cb) {
-        var command = new CreateSubscriptionDefinitionCommand(args);
+    }
+    createSubscriptionDefinition(args, optionsOrCb, cb) {
+        const command = new CreateSubscriptionDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.createSubscriptionDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateSubscriptionDefinitionVersionCommand(args);
+    }
+    createSubscriptionDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new CreateSubscriptionDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.deleteConnectorDefinition = function (args, optionsOrCb, cb) {
-        var command = new DeleteConnectorDefinitionCommand(args);
+    }
+    deleteConnectorDefinition(args, optionsOrCb, cb) {
+        const command = new DeleteConnectorDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.deleteCoreDefinition = function (args, optionsOrCb, cb) {
-        var command = new DeleteCoreDefinitionCommand(args);
+    }
+    deleteCoreDefinition(args, optionsOrCb, cb) {
+        const command = new DeleteCoreDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.deleteDeviceDefinition = function (args, optionsOrCb, cb) {
-        var command = new DeleteDeviceDefinitionCommand(args);
+    }
+    deleteDeviceDefinition(args, optionsOrCb, cb) {
+        const command = new DeleteDeviceDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.deleteFunctionDefinition = function (args, optionsOrCb, cb) {
-        var command = new DeleteFunctionDefinitionCommand(args);
+    }
+    deleteFunctionDefinition(args, optionsOrCb, cb) {
+        const command = new DeleteFunctionDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.deleteGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteGroupCommand(args);
+    }
+    deleteGroup(args, optionsOrCb, cb) {
+        const command = new DeleteGroupCommand(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);
         }
-    };
-    Greengrass.prototype.deleteLoggerDefinition = function (args, optionsOrCb, cb) {
-        var command = new DeleteLoggerDefinitionCommand(args);
+    }
+    deleteLoggerDefinition(args, optionsOrCb, cb) {
+        const command = new DeleteLoggerDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.deleteResourceDefinition = function (args, optionsOrCb, cb) {
-        var command = new DeleteResourceDefinitionCommand(args);
+    }
+    deleteResourceDefinition(args, optionsOrCb, cb) {
+        const command = new DeleteResourceDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.deleteSubscriptionDefinition = function (args, optionsOrCb, cb) {
-        var command = new DeleteSubscriptionDefinitionCommand(args);
+    }
+    deleteSubscriptionDefinition(args, optionsOrCb, cb) {
+        const command = new DeleteSubscriptionDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.disassociateRoleFromGroup = function (args, optionsOrCb, cb) {
-        var command = new DisassociateRoleFromGroupCommand(args);
+    }
+    disassociateRoleFromGroup(args, optionsOrCb, cb) {
+        const command = new DisassociateRoleFromGroupCommand(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);
         }
-    };
-    Greengrass.prototype.disassociateServiceRoleFromAccount = function (args, optionsOrCb, cb) {
-        var command = new DisassociateServiceRoleFromAccountCommand(args);
+    }
+    disassociateServiceRoleFromAccount(args, optionsOrCb, cb) {
+        const command = new DisassociateServiceRoleFromAccountCommand(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);
         }
-    };
-    Greengrass.prototype.getAssociatedRole = function (args, optionsOrCb, cb) {
-        var command = new GetAssociatedRoleCommand(args);
+    }
+    getAssociatedRole(args, optionsOrCb, cb) {
+        const command = new GetAssociatedRoleCommand(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);
         }
-    };
-    Greengrass.prototype.getBulkDeploymentStatus = function (args, optionsOrCb, cb) {
-        var command = new GetBulkDeploymentStatusCommand(args);
+    }
+    getBulkDeploymentStatus(args, optionsOrCb, cb) {
+        const command = new GetBulkDeploymentStatusCommand(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);
         }
-    };
-    Greengrass.prototype.getConnectivityInfo = function (args, optionsOrCb, cb) {
-        var command = new GetConnectivityInfoCommand(args);
+    }
+    getConnectivityInfo(args, optionsOrCb, cb) {
+        const command = new GetConnectivityInfoCommand(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);
         }
-    };
-    Greengrass.prototype.getConnectorDefinition = function (args, optionsOrCb, cb) {
-        var command = new GetConnectorDefinitionCommand(args);
+    }
+    getConnectorDefinition(args, optionsOrCb, cb) {
+        const command = new GetConnectorDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.getConnectorDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new GetConnectorDefinitionVersionCommand(args);
+    }
+    getConnectorDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new GetConnectorDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.getCoreDefinition = function (args, optionsOrCb, cb) {
-        var command = new GetCoreDefinitionCommand(args);
+    }
+    getCoreDefinition(args, optionsOrCb, cb) {
+        const command = new GetCoreDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.getCoreDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new GetCoreDefinitionVersionCommand(args);
+    }
+    getCoreDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new GetCoreDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.getDeploymentStatus = function (args, optionsOrCb, cb) {
-        var command = new GetDeploymentStatusCommand(args);
+    }
+    getDeploymentStatus(args, optionsOrCb, cb) {
+        const command = new GetDeploymentStatusCommand(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);
         }
-    };
-    Greengrass.prototype.getDeviceDefinition = function (args, optionsOrCb, cb) {
-        var command = new GetDeviceDefinitionCommand(args);
+    }
+    getDeviceDefinition(args, optionsOrCb, cb) {
+        const command = new GetDeviceDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.getDeviceDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new GetDeviceDefinitionVersionCommand(args);
+    }
+    getDeviceDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new GetDeviceDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.getFunctionDefinition = function (args, optionsOrCb, cb) {
-        var command = new GetFunctionDefinitionCommand(args);
+    }
+    getFunctionDefinition(args, optionsOrCb, cb) {
+        const command = new GetFunctionDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.getFunctionDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new GetFunctionDefinitionVersionCommand(args);
+    }
+    getFunctionDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new GetFunctionDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.getGroup = function (args, optionsOrCb, cb) {
-        var command = new GetGroupCommand(args);
+    }
+    getGroup(args, optionsOrCb, cb) {
+        const command = new GetGroupCommand(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);
         }
-    };
-    Greengrass.prototype.getGroupCertificateAuthority = function (args, optionsOrCb, cb) {
-        var command = new GetGroupCertificateAuthorityCommand(args);
+    }
+    getGroupCertificateAuthority(args, optionsOrCb, cb) {
+        const command = new GetGroupCertificateAuthorityCommand(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);
         }
-    };
-    Greengrass.prototype.getGroupCertificateConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetGroupCertificateConfigurationCommand(args);
+    }
+    getGroupCertificateConfiguration(args, optionsOrCb, cb) {
+        const command = new GetGroupCertificateConfigurationCommand(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);
         }
-    };
-    Greengrass.prototype.getGroupVersion = function (args, optionsOrCb, cb) {
-        var command = new GetGroupVersionCommand(args);
+    }
+    getGroupVersion(args, optionsOrCb, cb) {
+        const command = new GetGroupVersionCommand(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);
         }
-    };
-    Greengrass.prototype.getLoggerDefinition = function (args, optionsOrCb, cb) {
-        var command = new GetLoggerDefinitionCommand(args);
+    }
+    getLoggerDefinition(args, optionsOrCb, cb) {
+        const command = new GetLoggerDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.getLoggerDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new GetLoggerDefinitionVersionCommand(args);
+    }
+    getLoggerDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new GetLoggerDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.getResourceDefinition = function (args, optionsOrCb, cb) {
-        var command = new GetResourceDefinitionCommand(args);
+    }
+    getResourceDefinition(args, optionsOrCb, cb) {
+        const command = new GetResourceDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.getResourceDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new GetResourceDefinitionVersionCommand(args);
+    }
+    getResourceDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new GetResourceDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.getServiceRoleForAccount = function (args, optionsOrCb, cb) {
-        var command = new GetServiceRoleForAccountCommand(args);
+    }
+    getServiceRoleForAccount(args, optionsOrCb, cb) {
+        const command = new GetServiceRoleForAccountCommand(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);
         }
-    };
-    Greengrass.prototype.getSubscriptionDefinition = function (args, optionsOrCb, cb) {
-        var command = new GetSubscriptionDefinitionCommand(args);
+    }
+    getSubscriptionDefinition(args, optionsOrCb, cb) {
+        const command = new GetSubscriptionDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.getSubscriptionDefinitionVersion = function (args, optionsOrCb, cb) {
-        var command = new GetSubscriptionDefinitionVersionCommand(args);
+    }
+    getSubscriptionDefinitionVersion(args, optionsOrCb, cb) {
+        const command = new GetSubscriptionDefinitionVersionCommand(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);
         }
-    };
-    Greengrass.prototype.getThingRuntimeConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetThingRuntimeConfigurationCommand(args);
+    }
+    getThingRuntimeConfiguration(args, optionsOrCb, cb) {
+        const command = new GetThingRuntimeConfigurationCommand(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);
         }
-    };
-    Greengrass.prototype.listBulkDeploymentDetailedReports = function (args, optionsOrCb, cb) {
-        var command = new ListBulkDeploymentDetailedReportsCommand(args);
+    }
+    listBulkDeploymentDetailedReports(args, optionsOrCb, cb) {
+        const command = new ListBulkDeploymentDetailedReportsCommand(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);
         }
-    };
-    Greengrass.prototype.listBulkDeployments = function (args, optionsOrCb, cb) {
-        var command = new ListBulkDeploymentsCommand(args);
+    }
+    listBulkDeployments(args, optionsOrCb, cb) {
+        const command = new ListBulkDeploymentsCommand(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);
         }
-    };
-    Greengrass.prototype.listConnectorDefinitions = function (args, optionsOrCb, cb) {
-        var command = new ListConnectorDefinitionsCommand(args);
+    }
+    listConnectorDefinitions(args, optionsOrCb, cb) {
+        const command = new ListConnectorDefinitionsCommand(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);
         }
-    };
-    Greengrass.prototype.listConnectorDefinitionVersions = function (args, optionsOrCb, cb) {
-        var command = new ListConnectorDefinitionVersionsCommand(args);
+    }
+    listConnectorDefinitionVersions(args, optionsOrCb, cb) {
+        const command = new ListConnectorDefinitionVersionsCommand(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);
         }
-    };
-    Greengrass.prototype.listCoreDefinitions = function (args, optionsOrCb, cb) {
-        var command = new ListCoreDefinitionsCommand(args);
+    }
+    listCoreDefinitions(args, optionsOrCb, cb) {
+        const command = new ListCoreDefinitionsCommand(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);
         }
-    };
-    Greengrass.prototype.listCoreDefinitionVersions = function (args, optionsOrCb, cb) {
-        var command = new ListCoreDefinitionVersionsCommand(args);
+    }
+    listCoreDefinitionVersions(args, optionsOrCb, cb) {
+        const command = new ListCoreDefinitionVersionsCommand(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);
         }
-    };
-    Greengrass.prototype.listDeployments = function (args, optionsOrCb, cb) {
-        var command = new ListDeploymentsCommand(args);
+    }
+    listDeployments(args, optionsOrCb, cb) {
+        const command = new ListDeploymentsCommand(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);
         }
-    };
-    Greengrass.prototype.listDeviceDefinitions = function (args, optionsOrCb, cb) {
-        var command = new ListDeviceDefinitionsCommand(args);
+    }
+    listDeviceDefinitions(args, optionsOrCb, cb) {
+        const command = new ListDeviceDefinitionsCommand(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);
         }
-    };
-    Greengrass.prototype.listDeviceDefinitionVersions = function (args, optionsOrCb, cb) {
-        var command = new ListDeviceDefinitionVersionsCommand(args);
+    }
+    listDeviceDefinitionVersions(args, optionsOrCb, cb) {
+        const command = new ListDeviceDefinitionVersionsCommand(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);
         }
-    };
-    Greengrass.prototype.listFunctionDefinitions = function (args, optionsOrCb, cb) {
-        var command = new ListFunctionDefinitionsCommand(args);
+    }
+    listFunctionDefinitions(args, optionsOrCb, cb) {
+        const command = new ListFunctionDefinitionsCommand(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);
         }
-    };
-    Greengrass.prototype.listFunctionDefinitionVersions = function (args, optionsOrCb, cb) {
-        var command = new ListFunctionDefinitionVersionsCommand(args);
+    }
+    listFunctionDefinitionVersions(args, optionsOrCb, cb) {
+        const command = new ListFunctionDefinitionVersionsCommand(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);
         }
-    };
-    Greengrass.prototype.listGroupCertificateAuthorities = function (args, optionsOrCb, cb) {
-        var command = new ListGroupCertificateAuthoritiesCommand(args);
+    }
+    listGroupCertificateAuthorities(args, optionsOrCb, cb) {
+        const command = new ListGroupCertificateAuthoritiesCommand(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);
         }
-    };
-    Greengrass.prototype.listGroups = function (args, optionsOrCb, cb) {
-        var command = new ListGroupsCommand(args);
+    }
+    listGroups(args, optionsOrCb, cb) {
+        const command = new ListGroupsCommand(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);
         }
-    };
-    Greengrass.prototype.listGroupVersions = function (args, optionsOrCb, cb) {
-        var command = new ListGroupVersionsCommand(args);
+    }
+    listGroupVersions(args, optionsOrCb, cb) {
+        const command = new ListGroupVersionsCommand(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);
         }
-    };
-    Greengrass.prototype.listLoggerDefinitions = function (args, optionsOrCb, cb) {
-        var command = new ListLoggerDefinitionsCommand(args);
+    }
+    listLoggerDefinitions(args, optionsOrCb, cb) {
+        const command = new ListLoggerDefinitionsCommand(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);
         }
-    };
-    Greengrass.prototype.listLoggerDefinitionVersions = function (args, optionsOrCb, cb) {
-        var command = new ListLoggerDefinitionVersionsCommand(args);
+    }
+    listLoggerDefinitionVersions(args, optionsOrCb, cb) {
+        const command = new ListLoggerDefinitionVersionsCommand(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);
         }
-    };
-    Greengrass.prototype.listResourceDefinitions = function (args, optionsOrCb, cb) {
-        var command = new ListResourceDefinitionsCommand(args);
+    }
+    listResourceDefinitions(args, optionsOrCb, cb) {
+        const command = new ListResourceDefinitionsCommand(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);
         }
-    };
-    Greengrass.prototype.listResourceDefinitionVersions = function (args, optionsOrCb, cb) {
-        var command = new ListResourceDefinitionVersionsCommand(args);
+    }
+    listResourceDefinitionVersions(args, optionsOrCb, cb) {
+        const command = new ListResourceDefinitionVersionsCommand(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);
         }
-    };
-    Greengrass.prototype.listSubscriptionDefinitions = function (args, optionsOrCb, cb) {
-        var command = new ListSubscriptionDefinitionsCommand(args);
+    }
+    listSubscriptionDefinitions(args, optionsOrCb, cb) {
+        const command = new ListSubscriptionDefinitionsCommand(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);
         }
-    };
-    Greengrass.prototype.listSubscriptionDefinitionVersions = function (args, optionsOrCb, cb) {
-        var command = new ListSubscriptionDefinitionVersionsCommand(args);
+    }
+    listSubscriptionDefinitionVersions(args, optionsOrCb, cb) {
+        const command = new ListSubscriptionDefinitionVersionsCommand(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);
         }
-    };
-    Greengrass.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);
         }
-    };
-    Greengrass.prototype.resetDeployments = function (args, optionsOrCb, cb) {
-        var command = new ResetDeploymentsCommand(args);
+    }
+    resetDeployments(args, optionsOrCb, cb) {
+        const command = new ResetDeploymentsCommand(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);
         }
-    };
-    Greengrass.prototype.startBulkDeployment = function (args, optionsOrCb, cb) {
-        var command = new StartBulkDeploymentCommand(args);
+    }
+    startBulkDeployment(args, optionsOrCb, cb) {
+        const command = new StartBulkDeploymentCommand(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);
         }
-    };
-    Greengrass.prototype.stopBulkDeployment = function (args, optionsOrCb, cb) {
-        var command = new StopBulkDeploymentCommand(args);
+    }
+    stopBulkDeployment(args, optionsOrCb, cb) {
+        const command = new StopBulkDeploymentCommand(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);
         }
-    };
-    Greengrass.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);
         }
-    };
-    Greengrass.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);
         }
-    };
-    Greengrass.prototype.updateConnectivityInfo = function (args, optionsOrCb, cb) {
-        var command = new UpdateConnectivityInfoCommand(args);
+    }
+    updateConnectivityInfo(args, optionsOrCb, cb) {
+        const command = new UpdateConnectivityInfoCommand(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);
         }
-    };
-    Greengrass.prototype.updateConnectorDefinition = function (args, optionsOrCb, cb) {
-        var command = new UpdateConnectorDefinitionCommand(args);
+    }
+    updateConnectorDefinition(args, optionsOrCb, cb) {
+        const command = new UpdateConnectorDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.updateCoreDefinition = function (args, optionsOrCb, cb) {
-        var command = new UpdateCoreDefinitionCommand(args);
+    }
+    updateCoreDefinition(args, optionsOrCb, cb) {
+        const command = new UpdateCoreDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.updateDeviceDefinition = function (args, optionsOrCb, cb) {
-        var command = new UpdateDeviceDefinitionCommand(args);
+    }
+    updateDeviceDefinition(args, optionsOrCb, cb) {
+        const command = new UpdateDeviceDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.updateFunctionDefinition = function (args, optionsOrCb, cb) {
-        var command = new UpdateFunctionDefinitionCommand(args);
+    }
+    updateFunctionDefinition(args, optionsOrCb, cb) {
+        const command = new UpdateFunctionDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.updateGroup = function (args, optionsOrCb, cb) {
-        var command = new UpdateGroupCommand(args);
+    }
+    updateGroup(args, optionsOrCb, cb) {
+        const command = new UpdateGroupCommand(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);
         }
-    };
-    Greengrass.prototype.updateGroupCertificateConfiguration = function (args, optionsOrCb, cb) {
-        var command = new UpdateGroupCertificateConfigurationCommand(args);
+    }
+    updateGroupCertificateConfiguration(args, optionsOrCb, cb) {
+        const command = new UpdateGroupCertificateConfigurationCommand(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);
         }
-    };
-    Greengrass.prototype.updateLoggerDefinition = function (args, optionsOrCb, cb) {
-        var command = new UpdateLoggerDefinitionCommand(args);
+    }
+    updateLoggerDefinition(args, optionsOrCb, cb) {
+        const command = new UpdateLoggerDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.updateResourceDefinition = function (args, optionsOrCb, cb) {
-        var command = new UpdateResourceDefinitionCommand(args);
+    }
+    updateResourceDefinition(args, optionsOrCb, cb) {
+        const command = new UpdateResourceDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.updateSubscriptionDefinition = function (args, optionsOrCb, cb) {
-        var command = new UpdateSubscriptionDefinitionCommand(args);
+    }
+    updateSubscriptionDefinition(args, optionsOrCb, cb) {
+        const command = new UpdateSubscriptionDefinitionCommand(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);
         }
-    };
-    Greengrass.prototype.updateThingRuntimeConfiguration = function (args, optionsOrCb, cb) {
-        var command = new UpdateThingRuntimeConfigurationCommand(args);
+    }
+    updateThingRuntimeConfiguration(args, optionsOrCb, cb) {
+        const command = new UpdateThingRuntimeConfigurationCommand(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 Greengrass;
-}(GreengrassClient));
-export { Greengrass };
+    }
+}