@aws-sdk/client-iam 3.183.0 → 3.186.0

package/dist-es/IAM.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AddClientIDToOpenIDConnectProviderCommand, } from "./commands/AddClientIDToOpenIDConnectProviderCommand";
 import { AddRoleToInstanceProfileCommand, } from "./commands/AddRoleToInstanceProfileCommand";
 import { AddUserToGroupCommand, } from "./commands/AddUserToGroupCommand";
@@ -157,2217 +158,2223 @@ import { UploadServerCertificateCommand, } from "./commands/UploadServerCertific
 import { UploadSigningCertificateCommand, } from "./commands/UploadSigningCertificateCommand";
 import { UploadSSHPublicKeyCommand, } from "./commands/UploadSSHPublicKeyCommand";
 import { IAMClient } from "./IAMClient";
-export class IAM extends IAMClient {
-    addClientIDToOpenIDConnectProvider(args, optionsOrCb, cb) {
-        const command = new AddClientIDToOpenIDConnectProviderCommand(args);
+var IAM = (function (_super) {
+    __extends(IAM, _super);
+    function IAM() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    IAM.prototype.addClientIDToOpenIDConnectProvider = function (args, optionsOrCb, cb) {
+        var command = new AddClientIDToOpenIDConnectProviderCommand(args);
         if (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);
         }
-    }
-    addRoleToInstanceProfile(args, optionsOrCb, cb) {
-        const command = new AddRoleToInstanceProfileCommand(args);
+    };
+    IAM.prototype.addRoleToInstanceProfile = function (args, optionsOrCb, cb) {
+        var command = new AddRoleToInstanceProfileCommand(args);
         if (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);
         }
-    }
-    addUserToGroup(args, optionsOrCb, cb) {
-        const command = new AddUserToGroupCommand(args);
+    };
+    IAM.prototype.addUserToGroup = function (args, optionsOrCb, cb) {
+        var command = new AddUserToGroupCommand(args);
         if (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);
         }
-    }
-    attachGroupPolicy(args, optionsOrCb, cb) {
-        const command = new AttachGroupPolicyCommand(args);
+    };
+    IAM.prototype.attachGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new AttachGroupPolicyCommand(args);
         if (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);
         }
-    }
-    attachRolePolicy(args, optionsOrCb, cb) {
-        const command = new AttachRolePolicyCommand(args);
+    };
+    IAM.prototype.attachRolePolicy = function (args, optionsOrCb, cb) {
+        var command = new AttachRolePolicyCommand(args);
         if (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);
         }
-    }
-    attachUserPolicy(args, optionsOrCb, cb) {
-        const command = new AttachUserPolicyCommand(args);
+    };
+    IAM.prototype.attachUserPolicy = function (args, optionsOrCb, cb) {
+        var command = new AttachUserPolicyCommand(args);
         if (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);
         }
-    }
-    changePassword(args, optionsOrCb, cb) {
-        const command = new ChangePasswordCommand(args);
+    };
+    IAM.prototype.changePassword = function (args, optionsOrCb, cb) {
+        var command = new ChangePasswordCommand(args);
         if (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);
         }
-    }
-    createAccessKey(args, optionsOrCb, cb) {
-        const command = new CreateAccessKeyCommand(args);
+    };
+    IAM.prototype.createAccessKey = function (args, optionsOrCb, cb) {
+        var command = new CreateAccessKeyCommand(args);
         if (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);
         }
-    }
-    createAccountAlias(args, optionsOrCb, cb) {
-        const command = new CreateAccountAliasCommand(args);
+    };
+    IAM.prototype.createAccountAlias = function (args, optionsOrCb, cb) {
+        var command = new CreateAccountAliasCommand(args);
         if (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);
+    };
+    IAM.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);
         }
-    }
-    createInstanceProfile(args, optionsOrCb, cb) {
-        const command = new CreateInstanceProfileCommand(args);
+    };
+    IAM.prototype.createInstanceProfile = function (args, optionsOrCb, cb) {
+        var command = new CreateInstanceProfileCommand(args);
         if (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);
         }
-    }
-    createLoginProfile(args, optionsOrCb, cb) {
-        const command = new CreateLoginProfileCommand(args);
+    };
+    IAM.prototype.createLoginProfile = function (args, optionsOrCb, cb) {
+        var command = new CreateLoginProfileCommand(args);
         if (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);
         }
-    }
-    createOpenIDConnectProvider(args, optionsOrCb, cb) {
-        const command = new CreateOpenIDConnectProviderCommand(args);
+    };
+    IAM.prototype.createOpenIDConnectProvider = function (args, optionsOrCb, cb) {
+        var command = new CreateOpenIDConnectProviderCommand(args);
         if (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);
         }
-    }
-    createPolicy(args, optionsOrCb, cb) {
-        const command = new CreatePolicyCommand(args);
+    };
+    IAM.prototype.createPolicy = function (args, optionsOrCb, cb) {
+        var command = new CreatePolicyCommand(args);
         if (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);
         }
-    }
-    createPolicyVersion(args, optionsOrCb, cb) {
-        const command = new CreatePolicyVersionCommand(args);
+    };
+    IAM.prototype.createPolicyVersion = function (args, optionsOrCb, cb) {
+        var command = new CreatePolicyVersionCommand(args);
         if (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);
         }
-    }
-    createRole(args, optionsOrCb, cb) {
-        const command = new CreateRoleCommand(args);
+    };
+    IAM.prototype.createRole = function (args, optionsOrCb, cb) {
+        var command = new CreateRoleCommand(args);
         if (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);
         }
-    }
-    createSAMLProvider(args, optionsOrCb, cb) {
-        const command = new CreateSAMLProviderCommand(args);
+    };
+    IAM.prototype.createSAMLProvider = function (args, optionsOrCb, cb) {
+        var command = new CreateSAMLProviderCommand(args);
         if (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);
         }
-    }
-    createServiceLinkedRole(args, optionsOrCb, cb) {
-        const command = new CreateServiceLinkedRoleCommand(args);
+    };
+    IAM.prototype.createServiceLinkedRole = function (args, optionsOrCb, cb) {
+        var command = new CreateServiceLinkedRoleCommand(args);
         if (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);
         }
-    }
-    createServiceSpecificCredential(args, optionsOrCb, cb) {
-        const command = new CreateServiceSpecificCredentialCommand(args);
+    };
+    IAM.prototype.createServiceSpecificCredential = function (args, optionsOrCb, cb) {
+        var command = new CreateServiceSpecificCredentialCommand(args);
         if (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);
         }
-    }
-    createUser(args, optionsOrCb, cb) {
-        const command = new CreateUserCommand(args);
+    };
+    IAM.prototype.createUser = function (args, optionsOrCb, cb) {
+        var command = new CreateUserCommand(args);
         if (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);
         }
-    }
-    createVirtualMFADevice(args, optionsOrCb, cb) {
-        const command = new CreateVirtualMFADeviceCommand(args);
+    };
+    IAM.prototype.createVirtualMFADevice = function (args, optionsOrCb, cb) {
+        var command = new CreateVirtualMFADeviceCommand(args);
         if (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);
         }
-    }
-    deactivateMFADevice(args, optionsOrCb, cb) {
-        const command = new DeactivateMFADeviceCommand(args);
+    };
+    IAM.prototype.deactivateMFADevice = function (args, optionsOrCb, cb) {
+        var command = new DeactivateMFADeviceCommand(args);
         if (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);
         }
-    }
-    deleteAccessKey(args, optionsOrCb, cb) {
-        const command = new DeleteAccessKeyCommand(args);
+    };
+    IAM.prototype.deleteAccessKey = function (args, optionsOrCb, cb) {
+        var command = new DeleteAccessKeyCommand(args);
         if (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);
         }
-    }
-    deleteAccountAlias(args, optionsOrCb, cb) {
-        const command = new DeleteAccountAliasCommand(args);
+    };
+    IAM.prototype.deleteAccountAlias = function (args, optionsOrCb, cb) {
+        var command = new DeleteAccountAliasCommand(args);
         if (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);
         }
-    }
-    deleteAccountPasswordPolicy(args, optionsOrCb, cb) {
-        const command = new DeleteAccountPasswordPolicyCommand(args);
+    };
+    IAM.prototype.deleteAccountPasswordPolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteAccountPasswordPolicyCommand(args);
         if (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);
+    };
+    IAM.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);
         }
-    }
-    deleteGroupPolicy(args, optionsOrCb, cb) {
-        const command = new DeleteGroupPolicyCommand(args);
+    };
+    IAM.prototype.deleteGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteGroupPolicyCommand(args);
         if (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);
         }
-    }
-    deleteInstanceProfile(args, optionsOrCb, cb) {
-        const command = new DeleteInstanceProfileCommand(args);
+    };
+    IAM.prototype.deleteInstanceProfile = function (args, optionsOrCb, cb) {
+        var command = new DeleteInstanceProfileCommand(args);
         if (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);
         }
-    }
-    deleteLoginProfile(args, optionsOrCb, cb) {
-        const command = new DeleteLoginProfileCommand(args);
+    };
+    IAM.prototype.deleteLoginProfile = function (args, optionsOrCb, cb) {
+        var command = new DeleteLoginProfileCommand(args);
         if (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);
         }
-    }
-    deleteOpenIDConnectProvider(args, optionsOrCb, cb) {
-        const command = new DeleteOpenIDConnectProviderCommand(args);
+    };
+    IAM.prototype.deleteOpenIDConnectProvider = function (args, optionsOrCb, cb) {
+        var command = new DeleteOpenIDConnectProviderCommand(args);
         if (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);
         }
-    }
-    deletePolicy(args, optionsOrCb, cb) {
-        const command = new DeletePolicyCommand(args);
+    };
+    IAM.prototype.deletePolicy = function (args, optionsOrCb, cb) {
+        var command = new DeletePolicyCommand(args);
         if (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);
         }
-    }
-    deletePolicyVersion(args, optionsOrCb, cb) {
-        const command = new DeletePolicyVersionCommand(args);
+    };
+    IAM.prototype.deletePolicyVersion = function (args, optionsOrCb, cb) {
+        var command = new DeletePolicyVersionCommand(args);
         if (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);
         }
-    }
-    deleteRole(args, optionsOrCb, cb) {
-        const command = new DeleteRoleCommand(args);
+    };
+    IAM.prototype.deleteRole = function (args, optionsOrCb, cb) {
+        var command = new DeleteRoleCommand(args);
         if (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);
         }
-    }
-    deleteRolePermissionsBoundary(args, optionsOrCb, cb) {
-        const command = new DeleteRolePermissionsBoundaryCommand(args);
+    };
+    IAM.prototype.deleteRolePermissionsBoundary = function (args, optionsOrCb, cb) {
+        var command = new DeleteRolePermissionsBoundaryCommand(args);
         if (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);
         }
-    }
-    deleteRolePolicy(args, optionsOrCb, cb) {
-        const command = new DeleteRolePolicyCommand(args);
+    };
+    IAM.prototype.deleteRolePolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteRolePolicyCommand(args);
         if (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);
         }
-    }
-    deleteSAMLProvider(args, optionsOrCb, cb) {
-        const command = new DeleteSAMLProviderCommand(args);
+    };
+    IAM.prototype.deleteSAMLProvider = function (args, optionsOrCb, cb) {
+        var command = new DeleteSAMLProviderCommand(args);
         if (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);
         }
-    }
-    deleteServerCertificate(args, optionsOrCb, cb) {
-        const command = new DeleteServerCertificateCommand(args);
+    };
+    IAM.prototype.deleteServerCertificate = function (args, optionsOrCb, cb) {
+        var command = new DeleteServerCertificateCommand(args);
         if (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);
         }
-    }
-    deleteServiceLinkedRole(args, optionsOrCb, cb) {
-        const command = new DeleteServiceLinkedRoleCommand(args);
+    };
+    IAM.prototype.deleteServiceLinkedRole = function (args, optionsOrCb, cb) {
+        var command = new DeleteServiceLinkedRoleCommand(args);
         if (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);
         }
-    }
-    deleteServiceSpecificCredential(args, optionsOrCb, cb) {
-        const command = new DeleteServiceSpecificCredentialCommand(args);
+    };
+    IAM.prototype.deleteServiceSpecificCredential = function (args, optionsOrCb, cb) {
+        var command = new DeleteServiceSpecificCredentialCommand(args);
         if (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);
         }
-    }
-    deleteSigningCertificate(args, optionsOrCb, cb) {
-        const command = new DeleteSigningCertificateCommand(args);
+    };
+    IAM.prototype.deleteSigningCertificate = function (args, optionsOrCb, cb) {
+        var command = new DeleteSigningCertificateCommand(args);
         if (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);
         }
-    }
-    deleteSSHPublicKey(args, optionsOrCb, cb) {
-        const command = new DeleteSSHPublicKeyCommand(args);
+    };
+    IAM.prototype.deleteSSHPublicKey = function (args, optionsOrCb, cb) {
+        var command = new DeleteSSHPublicKeyCommand(args);
         if (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);
         }
-    }
-    deleteUser(args, optionsOrCb, cb) {
-        const command = new DeleteUserCommand(args);
+    };
+    IAM.prototype.deleteUser = function (args, optionsOrCb, cb) {
+        var command = new DeleteUserCommand(args);
         if (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);
         }
-    }
-    deleteUserPermissionsBoundary(args, optionsOrCb, cb) {
-        const command = new DeleteUserPermissionsBoundaryCommand(args);
+    };
+    IAM.prototype.deleteUserPermissionsBoundary = function (args, optionsOrCb, cb) {
+        var command = new DeleteUserPermissionsBoundaryCommand(args);
         if (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);
         }
-    }
-    deleteUserPolicy(args, optionsOrCb, cb) {
-        const command = new DeleteUserPolicyCommand(args);
+    };
+    IAM.prototype.deleteUserPolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteUserPolicyCommand(args);
         if (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);
         }
-    }
-    deleteVirtualMFADevice(args, optionsOrCb, cb) {
-        const command = new DeleteVirtualMFADeviceCommand(args);
+    };
+    IAM.prototype.deleteVirtualMFADevice = function (args, optionsOrCb, cb) {
+        var command = new DeleteVirtualMFADeviceCommand(args);
         if (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);
         }
-    }
-    detachGroupPolicy(args, optionsOrCb, cb) {
-        const command = new DetachGroupPolicyCommand(args);
+    };
+    IAM.prototype.detachGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new DetachGroupPolicyCommand(args);
         if (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);
         }
-    }
-    detachRolePolicy(args, optionsOrCb, cb) {
-        const command = new DetachRolePolicyCommand(args);
+    };
+    IAM.prototype.detachRolePolicy = function (args, optionsOrCb, cb) {
+        var command = new DetachRolePolicyCommand(args);
         if (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);
         }
-    }
-    detachUserPolicy(args, optionsOrCb, cb) {
-        const command = new DetachUserPolicyCommand(args);
+    };
+    IAM.prototype.detachUserPolicy = function (args, optionsOrCb, cb) {
+        var command = new DetachUserPolicyCommand(args);
         if (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);
         }
-    }
-    enableMFADevice(args, optionsOrCb, cb) {
-        const command = new EnableMFADeviceCommand(args);
+    };
+    IAM.prototype.enableMFADevice = function (args, optionsOrCb, cb) {
+        var command = new EnableMFADeviceCommand(args);
         if (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);
         }
-    }
-    generateCredentialReport(args, optionsOrCb, cb) {
-        const command = new GenerateCredentialReportCommand(args);
+    };
+    IAM.prototype.generateCredentialReport = function (args, optionsOrCb, cb) {
+        var command = new GenerateCredentialReportCommand(args);
         if (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);
         }
-    }
-    generateOrganizationsAccessReport(args, optionsOrCb, cb) {
-        const command = new GenerateOrganizationsAccessReportCommand(args);
+    };
+    IAM.prototype.generateOrganizationsAccessReport = function (args, optionsOrCb, cb) {
+        var command = new GenerateOrganizationsAccessReportCommand(args);
         if (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);
         }
-    }
-    generateServiceLastAccessedDetails(args, optionsOrCb, cb) {
-        const command = new GenerateServiceLastAccessedDetailsCommand(args);
+    };
+    IAM.prototype.generateServiceLastAccessedDetails = function (args, optionsOrCb, cb) {
+        var command = new GenerateServiceLastAccessedDetailsCommand(args);
         if (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);
         }
-    }
-    getAccessKeyLastUsed(args, optionsOrCb, cb) {
-        const command = new GetAccessKeyLastUsedCommand(args);
+    };
+    IAM.prototype.getAccessKeyLastUsed = function (args, optionsOrCb, cb) {
+        var command = new GetAccessKeyLastUsedCommand(args);
         if (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);
         }
-    }
-    getAccountAuthorizationDetails(args, optionsOrCb, cb) {
-        const command = new GetAccountAuthorizationDetailsCommand(args);
+    };
+    IAM.prototype.getAccountAuthorizationDetails = function (args, optionsOrCb, cb) {
+        var command = new GetAccountAuthorizationDetailsCommand(args);
         if (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);
         }
-    }
-    getAccountPasswordPolicy(args, optionsOrCb, cb) {
-        const command = new GetAccountPasswordPolicyCommand(args);
+    };
+    IAM.prototype.getAccountPasswordPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetAccountPasswordPolicyCommand(args);
         if (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);
         }
-    }
-    getAccountSummary(args, optionsOrCb, cb) {
-        const command = new GetAccountSummaryCommand(args);
+    };
+    IAM.prototype.getAccountSummary = function (args, optionsOrCb, cb) {
+        var command = new GetAccountSummaryCommand(args);
         if (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);
         }
-    }
-    getContextKeysForCustomPolicy(args, optionsOrCb, cb) {
-        const command = new GetContextKeysForCustomPolicyCommand(args);
+    };
+    IAM.prototype.getContextKeysForCustomPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetContextKeysForCustomPolicyCommand(args);
         if (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);
         }
-    }
-    getContextKeysForPrincipalPolicy(args, optionsOrCb, cb) {
-        const command = new GetContextKeysForPrincipalPolicyCommand(args);
+    };
+    IAM.prototype.getContextKeysForPrincipalPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetContextKeysForPrincipalPolicyCommand(args);
         if (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);
         }
-    }
-    getCredentialReport(args, optionsOrCb, cb) {
-        const command = new GetCredentialReportCommand(args);
+    };
+    IAM.prototype.getCredentialReport = function (args, optionsOrCb, cb) {
+        var command = new GetCredentialReportCommand(args);
         if (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);
+    };
+    IAM.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);
         }
-    }
-    getGroupPolicy(args, optionsOrCb, cb) {
-        const command = new GetGroupPolicyCommand(args);
+    };
+    IAM.prototype.getGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetGroupPolicyCommand(args);
         if (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);
         }
-    }
-    getInstanceProfile(args, optionsOrCb, cb) {
-        const command = new GetInstanceProfileCommand(args);
+    };
+    IAM.prototype.getInstanceProfile = function (args, optionsOrCb, cb) {
+        var command = new GetInstanceProfileCommand(args);
         if (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);
         }
-    }
-    getLoginProfile(args, optionsOrCb, cb) {
-        const command = new GetLoginProfileCommand(args);
+    };
+    IAM.prototype.getLoginProfile = function (args, optionsOrCb, cb) {
+        var command = new GetLoginProfileCommand(args);
         if (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);
         }
-    }
-    getOpenIDConnectProvider(args, optionsOrCb, cb) {
-        const command = new GetOpenIDConnectProviderCommand(args);
+    };
+    IAM.prototype.getOpenIDConnectProvider = function (args, optionsOrCb, cb) {
+        var command = new GetOpenIDConnectProviderCommand(args);
         if (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);
         }
-    }
-    getOrganizationsAccessReport(args, optionsOrCb, cb) {
-        const command = new GetOrganizationsAccessReportCommand(args);
+    };
+    IAM.prototype.getOrganizationsAccessReport = function (args, optionsOrCb, cb) {
+        var command = new GetOrganizationsAccessReportCommand(args);
         if (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);
         }
-    }
-    getPolicy(args, optionsOrCb, cb) {
-        const command = new GetPolicyCommand(args);
+    };
+    IAM.prototype.getPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetPolicyCommand(args);
         if (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);
         }
-    }
-    getPolicyVersion(args, optionsOrCb, cb) {
-        const command = new GetPolicyVersionCommand(args);
+    };
+    IAM.prototype.getPolicyVersion = function (args, optionsOrCb, cb) {
+        var command = new GetPolicyVersionCommand(args);
         if (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);
         }
-    }
-    getRole(args, optionsOrCb, cb) {
-        const command = new GetRoleCommand(args);
+    };
+    IAM.prototype.getRole = function (args, optionsOrCb, cb) {
+        var command = new GetRoleCommand(args);
         if (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);
         }
-    }
-    getRolePolicy(args, optionsOrCb, cb) {
-        const command = new GetRolePolicyCommand(args);
+    };
+    IAM.prototype.getRolePolicy = function (args, optionsOrCb, cb) {
+        var command = new GetRolePolicyCommand(args);
         if (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);
         }
-    }
-    getSAMLProvider(args, optionsOrCb, cb) {
-        const command = new GetSAMLProviderCommand(args);
+    };
+    IAM.prototype.getSAMLProvider = function (args, optionsOrCb, cb) {
+        var command = new GetSAMLProviderCommand(args);
         if (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);
         }
-    }
-    getServerCertificate(args, optionsOrCb, cb) {
-        const command = new GetServerCertificateCommand(args);
+    };
+    IAM.prototype.getServerCertificate = function (args, optionsOrCb, cb) {
+        var command = new GetServerCertificateCommand(args);
         if (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);
         }
-    }
-    getServiceLastAccessedDetails(args, optionsOrCb, cb) {
-        const command = new GetServiceLastAccessedDetailsCommand(args);
+    };
+    IAM.prototype.getServiceLastAccessedDetails = function (args, optionsOrCb, cb) {
+        var command = new GetServiceLastAccessedDetailsCommand(args);
         if (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);
         }
-    }
-    getServiceLastAccessedDetailsWithEntities(args, optionsOrCb, cb) {
-        const command = new GetServiceLastAccessedDetailsWithEntitiesCommand(args);
+    };
+    IAM.prototype.getServiceLastAccessedDetailsWithEntities = function (args, optionsOrCb, cb) {
+        var command = new GetServiceLastAccessedDetailsWithEntitiesCommand(args);
         if (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);
         }
-    }
-    getServiceLinkedRoleDeletionStatus(args, optionsOrCb, cb) {
-        const command = new GetServiceLinkedRoleDeletionStatusCommand(args);
+    };
+    IAM.prototype.getServiceLinkedRoleDeletionStatus = function (args, optionsOrCb, cb) {
+        var command = new GetServiceLinkedRoleDeletionStatusCommand(args);
         if (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);
         }
-    }
-    getSSHPublicKey(args, optionsOrCb, cb) {
-        const command = new GetSSHPublicKeyCommand(args);
+    };
+    IAM.prototype.getSSHPublicKey = function (args, optionsOrCb, cb) {
+        var command = new GetSSHPublicKeyCommand(args);
         if (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);
         }
-    }
-    getUser(args, optionsOrCb, cb) {
-        const command = new GetUserCommand(args);
+    };
+    IAM.prototype.getUser = function (args, optionsOrCb, cb) {
+        var command = new GetUserCommand(args);
         if (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);
         }
-    }
-    getUserPolicy(args, optionsOrCb, cb) {
-        const command = new GetUserPolicyCommand(args);
+    };
+    IAM.prototype.getUserPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetUserPolicyCommand(args);
         if (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);
         }
-    }
-    listAccessKeys(args, optionsOrCb, cb) {
-        const command = new ListAccessKeysCommand(args);
+    };
+    IAM.prototype.listAccessKeys = function (args, optionsOrCb, cb) {
+        var command = new ListAccessKeysCommand(args);
         if (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);
         }
-    }
-    listAccountAliases(args, optionsOrCb, cb) {
-        const command = new ListAccountAliasesCommand(args);
+    };
+    IAM.prototype.listAccountAliases = function (args, optionsOrCb, cb) {
+        var command = new ListAccountAliasesCommand(args);
         if (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);
         }
-    }
-    listAttachedGroupPolicies(args, optionsOrCb, cb) {
-        const command = new ListAttachedGroupPoliciesCommand(args);
+    };
+    IAM.prototype.listAttachedGroupPolicies = function (args, optionsOrCb, cb) {
+        var command = new ListAttachedGroupPoliciesCommand(args);
         if (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);
         }
-    }
-    listAttachedRolePolicies(args, optionsOrCb, cb) {
-        const command = new ListAttachedRolePoliciesCommand(args);
+    };
+    IAM.prototype.listAttachedRolePolicies = function (args, optionsOrCb, cb) {
+        var command = new ListAttachedRolePoliciesCommand(args);
         if (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);
         }
-    }
-    listAttachedUserPolicies(args, optionsOrCb, cb) {
-        const command = new ListAttachedUserPoliciesCommand(args);
+    };
+    IAM.prototype.listAttachedUserPolicies = function (args, optionsOrCb, cb) {
+        var command = new ListAttachedUserPoliciesCommand(args);
         if (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);
         }
-    }
-    listEntitiesForPolicy(args, optionsOrCb, cb) {
-        const command = new ListEntitiesForPolicyCommand(args);
+    };
+    IAM.prototype.listEntitiesForPolicy = function (args, optionsOrCb, cb) {
+        var command = new ListEntitiesForPolicyCommand(args);
         if (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);
         }
-    }
-    listGroupPolicies(args, optionsOrCb, cb) {
-        const command = new ListGroupPoliciesCommand(args);
+    };
+    IAM.prototype.listGroupPolicies = function (args, optionsOrCb, cb) {
+        var command = new ListGroupPoliciesCommand(args);
         if (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);
+    };
+    IAM.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);
         }
-    }
-    listGroupsForUser(args, optionsOrCb, cb) {
-        const command = new ListGroupsForUserCommand(args);
+    };
+    IAM.prototype.listGroupsForUser = function (args, optionsOrCb, cb) {
+        var command = new ListGroupsForUserCommand(args);
         if (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);
         }
-    }
-    listInstanceProfiles(args, optionsOrCb, cb) {
-        const command = new ListInstanceProfilesCommand(args);
+    };
+    IAM.prototype.listInstanceProfiles = function (args, optionsOrCb, cb) {
+        var command = new ListInstanceProfilesCommand(args);
         if (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);
         }
-    }
-    listInstanceProfilesForRole(args, optionsOrCb, cb) {
-        const command = new ListInstanceProfilesForRoleCommand(args);
+    };
+    IAM.prototype.listInstanceProfilesForRole = function (args, optionsOrCb, cb) {
+        var command = new ListInstanceProfilesForRoleCommand(args);
         if (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);
         }
-    }
-    listInstanceProfileTags(args, optionsOrCb, cb) {
-        const command = new ListInstanceProfileTagsCommand(args);
+    };
+    IAM.prototype.listInstanceProfileTags = function (args, optionsOrCb, cb) {
+        var command = new ListInstanceProfileTagsCommand(args);
         if (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);
         }
-    }
-    listMFADevices(args, optionsOrCb, cb) {
-        const command = new ListMFADevicesCommand(args);
+    };
+    IAM.prototype.listMFADevices = function (args, optionsOrCb, cb) {
+        var command = new ListMFADevicesCommand(args);
         if (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);
         }
-    }
-    listMFADeviceTags(args, optionsOrCb, cb) {
-        const command = new ListMFADeviceTagsCommand(args);
+    };
+    IAM.prototype.listMFADeviceTags = function (args, optionsOrCb, cb) {
+        var command = new ListMFADeviceTagsCommand(args);
         if (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);
         }
-    }
-    listOpenIDConnectProviders(args, optionsOrCb, cb) {
-        const command = new ListOpenIDConnectProvidersCommand(args);
+    };
+    IAM.prototype.listOpenIDConnectProviders = function (args, optionsOrCb, cb) {
+        var command = new ListOpenIDConnectProvidersCommand(args);
         if (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);
         }
-    }
-    listOpenIDConnectProviderTags(args, optionsOrCb, cb) {
-        const command = new ListOpenIDConnectProviderTagsCommand(args);
+    };
+    IAM.prototype.listOpenIDConnectProviderTags = function (args, optionsOrCb, cb) {
+        var command = new ListOpenIDConnectProviderTagsCommand(args);
         if (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);
         }
-    }
-    listPolicies(args, optionsOrCb, cb) {
-        const command = new ListPoliciesCommand(args);
+    };
+    IAM.prototype.listPolicies = function (args, optionsOrCb, cb) {
+        var command = new ListPoliciesCommand(args);
         if (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);
         }
-    }
-    listPoliciesGrantingServiceAccess(args, optionsOrCb, cb) {
-        const command = new ListPoliciesGrantingServiceAccessCommand(args);
+    };
+    IAM.prototype.listPoliciesGrantingServiceAccess = function (args, optionsOrCb, cb) {
+        var command = new ListPoliciesGrantingServiceAccessCommand(args);
         if (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);
         }
-    }
-    listPolicyTags(args, optionsOrCb, cb) {
-        const command = new ListPolicyTagsCommand(args);
+    };
+    IAM.prototype.listPolicyTags = function (args, optionsOrCb, cb) {
+        var command = new ListPolicyTagsCommand(args);
         if (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);
         }
-    }
-    listPolicyVersions(args, optionsOrCb, cb) {
-        const command = new ListPolicyVersionsCommand(args);
+    };
+    IAM.prototype.listPolicyVersions = function (args, optionsOrCb, cb) {
+        var command = new ListPolicyVersionsCommand(args);
         if (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);
         }
-    }
-    listRolePolicies(args, optionsOrCb, cb) {
-        const command = new ListRolePoliciesCommand(args);
+    };
+    IAM.prototype.listRolePolicies = function (args, optionsOrCb, cb) {
+        var command = new ListRolePoliciesCommand(args);
         if (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);
         }
-    }
-    listRoles(args, optionsOrCb, cb) {
-        const command = new ListRolesCommand(args);
+    };
+    IAM.prototype.listRoles = function (args, optionsOrCb, cb) {
+        var command = new ListRolesCommand(args);
         if (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);
         }
-    }
-    listRoleTags(args, optionsOrCb, cb) {
-        const command = new ListRoleTagsCommand(args);
+    };
+    IAM.prototype.listRoleTags = function (args, optionsOrCb, cb) {
+        var command = new ListRoleTagsCommand(args);
         if (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);
         }
-    }
-    listSAMLProviders(args, optionsOrCb, cb) {
-        const command = new ListSAMLProvidersCommand(args);
+    };
+    IAM.prototype.listSAMLProviders = function (args, optionsOrCb, cb) {
+        var command = new ListSAMLProvidersCommand(args);
         if (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);
         }
-    }
-    listSAMLProviderTags(args, optionsOrCb, cb) {
-        const command = new ListSAMLProviderTagsCommand(args);
+    };
+    IAM.prototype.listSAMLProviderTags = function (args, optionsOrCb, cb) {
+        var command = new ListSAMLProviderTagsCommand(args);
         if (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);
         }
-    }
-    listServerCertificates(args, optionsOrCb, cb) {
-        const command = new ListServerCertificatesCommand(args);
+    };
+    IAM.prototype.listServerCertificates = function (args, optionsOrCb, cb) {
+        var command = new ListServerCertificatesCommand(args);
         if (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);
         }
-    }
-    listServerCertificateTags(args, optionsOrCb, cb) {
-        const command = new ListServerCertificateTagsCommand(args);
+    };
+    IAM.prototype.listServerCertificateTags = function (args, optionsOrCb, cb) {
+        var command = new ListServerCertificateTagsCommand(args);
         if (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);
         }
-    }
-    listServiceSpecificCredentials(args, optionsOrCb, cb) {
-        const command = new ListServiceSpecificCredentialsCommand(args);
+    };
+    IAM.prototype.listServiceSpecificCredentials = function (args, optionsOrCb, cb) {
+        var command = new ListServiceSpecificCredentialsCommand(args);
         if (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);
         }
-    }
-    listSigningCertificates(args, optionsOrCb, cb) {
-        const command = new ListSigningCertificatesCommand(args);
+    };
+    IAM.prototype.listSigningCertificates = function (args, optionsOrCb, cb) {
+        var command = new ListSigningCertificatesCommand(args);
         if (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);
         }
-    }
-    listSSHPublicKeys(args, optionsOrCb, cb) {
-        const command = new ListSSHPublicKeysCommand(args);
+    };
+    IAM.prototype.listSSHPublicKeys = function (args, optionsOrCb, cb) {
+        var command = new ListSSHPublicKeysCommand(args);
         if (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);
         }
-    }
-    listUserPolicies(args, optionsOrCb, cb) {
-        const command = new ListUserPoliciesCommand(args);
+    };
+    IAM.prototype.listUserPolicies = function (args, optionsOrCb, cb) {
+        var command = new ListUserPoliciesCommand(args);
         if (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);
         }
-    }
-    listUsers(args, optionsOrCb, cb) {
-        const command = new ListUsersCommand(args);
+    };
+    IAM.prototype.listUsers = function (args, optionsOrCb, cb) {
+        var command = new ListUsersCommand(args);
         if (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);
         }
-    }
-    listUserTags(args, optionsOrCb, cb) {
-        const command = new ListUserTagsCommand(args);
+    };
+    IAM.prototype.listUserTags = function (args, optionsOrCb, cb) {
+        var command = new ListUserTagsCommand(args);
         if (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);
         }
-    }
-    listVirtualMFADevices(args, optionsOrCb, cb) {
-        const command = new ListVirtualMFADevicesCommand(args);
+    };
+    IAM.prototype.listVirtualMFADevices = function (args, optionsOrCb, cb) {
+        var command = new ListVirtualMFADevicesCommand(args);
         if (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);
         }
-    }
-    putGroupPolicy(args, optionsOrCb, cb) {
-        const command = new PutGroupPolicyCommand(args);
+    };
+    IAM.prototype.putGroupPolicy = function (args, optionsOrCb, cb) {
+        var command = new PutGroupPolicyCommand(args);
         if (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);
         }
-    }
-    putRolePermissionsBoundary(args, optionsOrCb, cb) {
-        const command = new PutRolePermissionsBoundaryCommand(args);
+    };
+    IAM.prototype.putRolePermissionsBoundary = function (args, optionsOrCb, cb) {
+        var command = new PutRolePermissionsBoundaryCommand(args);
         if (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);
         }
-    }
-    putRolePolicy(args, optionsOrCb, cb) {
-        const command = new PutRolePolicyCommand(args);
+    };
+    IAM.prototype.putRolePolicy = function (args, optionsOrCb, cb) {
+        var command = new PutRolePolicyCommand(args);
         if (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);
         }
-    }
-    putUserPermissionsBoundary(args, optionsOrCb, cb) {
-        const command = new PutUserPermissionsBoundaryCommand(args);
+    };
+    IAM.prototype.putUserPermissionsBoundary = function (args, optionsOrCb, cb) {
+        var command = new PutUserPermissionsBoundaryCommand(args);
         if (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);
         }
-    }
-    putUserPolicy(args, optionsOrCb, cb) {
-        const command = new PutUserPolicyCommand(args);
+    };
+    IAM.prototype.putUserPolicy = function (args, optionsOrCb, cb) {
+        var command = new PutUserPolicyCommand(args);
         if (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);
         }
-    }
-    removeClientIDFromOpenIDConnectProvider(args, optionsOrCb, cb) {
-        const command = new RemoveClientIDFromOpenIDConnectProviderCommand(args);
+    };
+    IAM.prototype.removeClientIDFromOpenIDConnectProvider = function (args, optionsOrCb, cb) {
+        var command = new RemoveClientIDFromOpenIDConnectProviderCommand(args);
         if (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);
         }
-    }
-    removeRoleFromInstanceProfile(args, optionsOrCb, cb) {
-        const command = new RemoveRoleFromInstanceProfileCommand(args);
+    };
+    IAM.prototype.removeRoleFromInstanceProfile = function (args, optionsOrCb, cb) {
+        var command = new RemoveRoleFromInstanceProfileCommand(args);
         if (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);
         }
-    }
-    removeUserFromGroup(args, optionsOrCb, cb) {
-        const command = new RemoveUserFromGroupCommand(args);
+    };
+    IAM.prototype.removeUserFromGroup = function (args, optionsOrCb, cb) {
+        var command = new RemoveUserFromGroupCommand(args);
         if (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);
         }
-    }
-    resetServiceSpecificCredential(args, optionsOrCb, cb) {
-        const command = new ResetServiceSpecificCredentialCommand(args);
+    };
+    IAM.prototype.resetServiceSpecificCredential = function (args, optionsOrCb, cb) {
+        var command = new ResetServiceSpecificCredentialCommand(args);
         if (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);
         }
-    }
-    resyncMFADevice(args, optionsOrCb, cb) {
-        const command = new ResyncMFADeviceCommand(args);
+    };
+    IAM.prototype.resyncMFADevice = function (args, optionsOrCb, cb) {
+        var command = new ResyncMFADeviceCommand(args);
         if (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);
         }
-    }
-    setDefaultPolicyVersion(args, optionsOrCb, cb) {
-        const command = new SetDefaultPolicyVersionCommand(args);
+    };
+    IAM.prototype.setDefaultPolicyVersion = function (args, optionsOrCb, cb) {
+        var command = new SetDefaultPolicyVersionCommand(args);
         if (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);
         }
-    }
-    setSecurityTokenServicePreferences(args, optionsOrCb, cb) {
-        const command = new SetSecurityTokenServicePreferencesCommand(args);
+    };
+    IAM.prototype.setSecurityTokenServicePreferences = function (args, optionsOrCb, cb) {
+        var command = new SetSecurityTokenServicePreferencesCommand(args);
         if (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);
         }
-    }
-    simulateCustomPolicy(args, optionsOrCb, cb) {
-        const command = new SimulateCustomPolicyCommand(args);
+    };
+    IAM.prototype.simulateCustomPolicy = function (args, optionsOrCb, cb) {
+        var command = new SimulateCustomPolicyCommand(args);
         if (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);
         }
-    }
-    simulatePrincipalPolicy(args, optionsOrCb, cb) {
-        const command = new SimulatePrincipalPolicyCommand(args);
+    };
+    IAM.prototype.simulatePrincipalPolicy = function (args, optionsOrCb, cb) {
+        var command = new SimulatePrincipalPolicyCommand(args);
         if (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);
         }
-    }
-    tagInstanceProfile(args, optionsOrCb, cb) {
-        const command = new TagInstanceProfileCommand(args);
+    };
+    IAM.prototype.tagInstanceProfile = function (args, optionsOrCb, cb) {
+        var command = new TagInstanceProfileCommand(args);
         if (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);
         }
-    }
-    tagMFADevice(args, optionsOrCb, cb) {
-        const command = new TagMFADeviceCommand(args);
+    };
+    IAM.prototype.tagMFADevice = function (args, optionsOrCb, cb) {
+        var command = new TagMFADeviceCommand(args);
         if (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);
         }
-    }
-    tagOpenIDConnectProvider(args, optionsOrCb, cb) {
-        const command = new TagOpenIDConnectProviderCommand(args);
+    };
+    IAM.prototype.tagOpenIDConnectProvider = function (args, optionsOrCb, cb) {
+        var command = new TagOpenIDConnectProviderCommand(args);
         if (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);
         }
-    }
-    tagPolicy(args, optionsOrCb, cb) {
-        const command = new TagPolicyCommand(args);
+    };
+    IAM.prototype.tagPolicy = function (args, optionsOrCb, cb) {
+        var command = new TagPolicyCommand(args);
         if (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);
         }
-    }
-    tagRole(args, optionsOrCb, cb) {
-        const command = new TagRoleCommand(args);
+    };
+    IAM.prototype.tagRole = function (args, optionsOrCb, cb) {
+        var command = new TagRoleCommand(args);
         if (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);
         }
-    }
-    tagSAMLProvider(args, optionsOrCb, cb) {
-        const command = new TagSAMLProviderCommand(args);
+    };
+    IAM.prototype.tagSAMLProvider = function (args, optionsOrCb, cb) {
+        var command = new TagSAMLProviderCommand(args);
         if (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);
         }
-    }
-    tagServerCertificate(args, optionsOrCb, cb) {
-        const command = new TagServerCertificateCommand(args);
+    };
+    IAM.prototype.tagServerCertificate = function (args, optionsOrCb, cb) {
+        var command = new TagServerCertificateCommand(args);
         if (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);
         }
-    }
-    tagUser(args, optionsOrCb, cb) {
-        const command = new TagUserCommand(args);
+    };
+    IAM.prototype.tagUser = function (args, optionsOrCb, cb) {
+        var command = new TagUserCommand(args);
         if (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);
         }
-    }
-    untagInstanceProfile(args, optionsOrCb, cb) {
-        const command = new UntagInstanceProfileCommand(args);
+    };
+    IAM.prototype.untagInstanceProfile = function (args, optionsOrCb, cb) {
+        var command = new UntagInstanceProfileCommand(args);
         if (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);
         }
-    }
-    untagMFADevice(args, optionsOrCb, cb) {
-        const command = new UntagMFADeviceCommand(args);
+    };
+    IAM.prototype.untagMFADevice = function (args, optionsOrCb, cb) {
+        var command = new UntagMFADeviceCommand(args);
         if (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);
         }
-    }
-    untagOpenIDConnectProvider(args, optionsOrCb, cb) {
-        const command = new UntagOpenIDConnectProviderCommand(args);
+    };
+    IAM.prototype.untagOpenIDConnectProvider = function (args, optionsOrCb, cb) {
+        var command = new UntagOpenIDConnectProviderCommand(args);
         if (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);
         }
-    }
-    untagPolicy(args, optionsOrCb, cb) {
-        const command = new UntagPolicyCommand(args);
+    };
+    IAM.prototype.untagPolicy = function (args, optionsOrCb, cb) {
+        var command = new UntagPolicyCommand(args);
         if (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);
         }
-    }
-    untagRole(args, optionsOrCb, cb) {
-        const command = new UntagRoleCommand(args);
+    };
+    IAM.prototype.untagRole = function (args, optionsOrCb, cb) {
+        var command = new UntagRoleCommand(args);
         if (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);
         }
-    }
-    untagSAMLProvider(args, optionsOrCb, cb) {
-        const command = new UntagSAMLProviderCommand(args);
+    };
+    IAM.prototype.untagSAMLProvider = function (args, optionsOrCb, cb) {
+        var command = new UntagSAMLProviderCommand(args);
         if (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);
         }
-    }
-    untagServerCertificate(args, optionsOrCb, cb) {
-        const command = new UntagServerCertificateCommand(args);
+    };
+    IAM.prototype.untagServerCertificate = function (args, optionsOrCb, cb) {
+        var command = new UntagServerCertificateCommand(args);
         if (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);
         }
-    }
-    untagUser(args, optionsOrCb, cb) {
-        const command = new UntagUserCommand(args);
+    };
+    IAM.prototype.untagUser = function (args, optionsOrCb, cb) {
+        var command = new UntagUserCommand(args);
         if (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);
         }
-    }
-    updateAccessKey(args, optionsOrCb, cb) {
-        const command = new UpdateAccessKeyCommand(args);
+    };
+    IAM.prototype.updateAccessKey = function (args, optionsOrCb, cb) {
+        var command = new UpdateAccessKeyCommand(args);
         if (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);
         }
-    }
-    updateAccountPasswordPolicy(args, optionsOrCb, cb) {
-        const command = new UpdateAccountPasswordPolicyCommand(args);
+    };
+    IAM.prototype.updateAccountPasswordPolicy = function (args, optionsOrCb, cb) {
+        var command = new UpdateAccountPasswordPolicyCommand(args);
         if (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);
         }
-    }
-    updateAssumeRolePolicy(args, optionsOrCb, cb) {
-        const command = new UpdateAssumeRolePolicyCommand(args);
+    };
+    IAM.prototype.updateAssumeRolePolicy = function (args, optionsOrCb, cb) {
+        var command = new UpdateAssumeRolePolicyCommand(args);
         if (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);
+    };
+    IAM.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);
         }
-    }
-    updateLoginProfile(args, optionsOrCb, cb) {
-        const command = new UpdateLoginProfileCommand(args);
+    };
+    IAM.prototype.updateLoginProfile = function (args, optionsOrCb, cb) {
+        var command = new UpdateLoginProfileCommand(args);
         if (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);
         }
-    }
-    updateOpenIDConnectProviderThumbprint(args, optionsOrCb, cb) {
-        const command = new UpdateOpenIDConnectProviderThumbprintCommand(args);
+    };
+    IAM.prototype.updateOpenIDConnectProviderThumbprint = function (args, optionsOrCb, cb) {
+        var command = new UpdateOpenIDConnectProviderThumbprintCommand(args);
         if (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);
         }
-    }
-    updateRole(args, optionsOrCb, cb) {
-        const command = new UpdateRoleCommand(args);
+    };
+    IAM.prototype.updateRole = function (args, optionsOrCb, cb) {
+        var command = new UpdateRoleCommand(args);
         if (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);
         }
-    }
-    updateRoleDescription(args, optionsOrCb, cb) {
-        const command = new UpdateRoleDescriptionCommand(args);
+    };
+    IAM.prototype.updateRoleDescription = function (args, optionsOrCb, cb) {
+        var command = new UpdateRoleDescriptionCommand(args);
         if (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);
         }
-    }
-    updateSAMLProvider(args, optionsOrCb, cb) {
-        const command = new UpdateSAMLProviderCommand(args);
+    };
+    IAM.prototype.updateSAMLProvider = function (args, optionsOrCb, cb) {
+        var command = new UpdateSAMLProviderCommand(args);
         if (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);
         }
-    }
-    updateServerCertificate(args, optionsOrCb, cb) {
-        const command = new UpdateServerCertificateCommand(args);
+    };
+    IAM.prototype.updateServerCertificate = function (args, optionsOrCb, cb) {
+        var command = new UpdateServerCertificateCommand(args);
         if (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);
         }
-    }
-    updateServiceSpecificCredential(args, optionsOrCb, cb) {
-        const command = new UpdateServiceSpecificCredentialCommand(args);
+    };
+    IAM.prototype.updateServiceSpecificCredential = function (args, optionsOrCb, cb) {
+        var command = new UpdateServiceSpecificCredentialCommand(args);
         if (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);
         }
-    }
-    updateSigningCertificate(args, optionsOrCb, cb) {
-        const command = new UpdateSigningCertificateCommand(args);
+    };
+    IAM.prototype.updateSigningCertificate = function (args, optionsOrCb, cb) {
+        var command = new UpdateSigningCertificateCommand(args);
         if (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);
         }
-    }
-    updateSSHPublicKey(args, optionsOrCb, cb) {
-        const command = new UpdateSSHPublicKeyCommand(args);
+    };
+    IAM.prototype.updateSSHPublicKey = function (args, optionsOrCb, cb) {
+        var command = new UpdateSSHPublicKeyCommand(args);
         if (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);
         }
-    }
-    updateUser(args, optionsOrCb, cb) {
-        const command = new UpdateUserCommand(args);
+    };
+    IAM.prototype.updateUser = function (args, optionsOrCb, cb) {
+        var command = new UpdateUserCommand(args);
         if (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);
         }
-    }
-    uploadServerCertificate(args, optionsOrCb, cb) {
-        const command = new UploadServerCertificateCommand(args);
+    };
+    IAM.prototype.uploadServerCertificate = function (args, optionsOrCb, cb) {
+        var command = new UploadServerCertificateCommand(args);
         if (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);
         }
-    }
-    uploadSigningCertificate(args, optionsOrCb, cb) {
-        const command = new UploadSigningCertificateCommand(args);
+    };
+    IAM.prototype.uploadSigningCertificate = function (args, optionsOrCb, cb) {
+        var command = new UploadSigningCertificateCommand(args);
         if (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);
         }
-    }
-    uploadSSHPublicKey(args, optionsOrCb, cb) {
-        const command = new UploadSSHPublicKeyCommand(args);
+    };
+    IAM.prototype.uploadSSHPublicKey = function (args, optionsOrCb, cb) {
+        var command = new UploadSSHPublicKeyCommand(args);
         if (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 IAM;
+}(IAMClient));
+export { IAM };