@aws-sdk/client-greengrass 3.183.0 → 3.186.0

package/dist-es/Greengrass.js

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