@aws-sdk/client-cognito-identity-provider 3.185.0 → 3.188.0

package/dist-es/CognitoIdentityProvider.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { CognitoIdentityProviderClient } from "./CognitoIdentityProviderClient";
 import { AddCustomAttributesCommand, } from "./commands/AddCustomAttributesCommand";
 import { AdminAddUserToGroupCommand, } from "./commands/AdminAddUserToGroupCommand";
@@ -101,1425 +100,1419 @@ import { UpdateUserPoolCommand, } from "./commands/UpdateUserPoolCommand";
 import { UpdateUserPoolDomainCommand, } from "./commands/UpdateUserPoolDomainCommand";
 import { VerifySoftwareTokenCommand, } from "./commands/VerifySoftwareTokenCommand";
 import { VerifyUserAttributeCommand, } from "./commands/VerifyUserAttributeCommand";
-var CognitoIdentityProvider = (function (_super) {
-    __extends(CognitoIdentityProvider, _super);
-    function CognitoIdentityProvider() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    CognitoIdentityProvider.prototype.addCustomAttributes = function (args, optionsOrCb, cb) {
-        var command = new AddCustomAttributesCommand(args);
+export class CognitoIdentityProvider extends CognitoIdentityProviderClient {
+    addCustomAttributes(args, optionsOrCb, cb) {
+        const command = new AddCustomAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminAddUserToGroup = function (args, optionsOrCb, cb) {
-        var command = new AdminAddUserToGroupCommand(args);
+    }
+    adminAddUserToGroup(args, optionsOrCb, cb) {
+        const command = new AdminAddUserToGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminConfirmSignUp = function (args, optionsOrCb, cb) {
-        var command = new AdminConfirmSignUpCommand(args);
+    }
+    adminConfirmSignUp(args, optionsOrCb, cb) {
+        const command = new AdminConfirmSignUpCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminCreateUser = function (args, optionsOrCb, cb) {
-        var command = new AdminCreateUserCommand(args);
+    }
+    adminCreateUser(args, optionsOrCb, cb) {
+        const command = new AdminCreateUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminDeleteUser = function (args, optionsOrCb, cb) {
-        var command = new AdminDeleteUserCommand(args);
+    }
+    adminDeleteUser(args, optionsOrCb, cb) {
+        const command = new AdminDeleteUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminDeleteUserAttributes = function (args, optionsOrCb, cb) {
-        var command = new AdminDeleteUserAttributesCommand(args);
+    }
+    adminDeleteUserAttributes(args, optionsOrCb, cb) {
+        const command = new AdminDeleteUserAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminDisableProviderForUser = function (args, optionsOrCb, cb) {
-        var command = new AdminDisableProviderForUserCommand(args);
+    }
+    adminDisableProviderForUser(args, optionsOrCb, cb) {
+        const command = new AdminDisableProviderForUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminDisableUser = function (args, optionsOrCb, cb) {
-        var command = new AdminDisableUserCommand(args);
+    }
+    adminDisableUser(args, optionsOrCb, cb) {
+        const command = new AdminDisableUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminEnableUser = function (args, optionsOrCb, cb) {
-        var command = new AdminEnableUserCommand(args);
+    }
+    adminEnableUser(args, optionsOrCb, cb) {
+        const command = new AdminEnableUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminForgetDevice = function (args, optionsOrCb, cb) {
-        var command = new AdminForgetDeviceCommand(args);
+    }
+    adminForgetDevice(args, optionsOrCb, cb) {
+        const command = new AdminForgetDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminGetDevice = function (args, optionsOrCb, cb) {
-        var command = new AdminGetDeviceCommand(args);
+    }
+    adminGetDevice(args, optionsOrCb, cb) {
+        const command = new AdminGetDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminGetUser = function (args, optionsOrCb, cb) {
-        var command = new AdminGetUserCommand(args);
+    }
+    adminGetUser(args, optionsOrCb, cb) {
+        const command = new AdminGetUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminInitiateAuth = function (args, optionsOrCb, cb) {
-        var command = new AdminInitiateAuthCommand(args);
+    }
+    adminInitiateAuth(args, optionsOrCb, cb) {
+        const command = new AdminInitiateAuthCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminLinkProviderForUser = function (args, optionsOrCb, cb) {
-        var command = new AdminLinkProviderForUserCommand(args);
+    }
+    adminLinkProviderForUser(args, optionsOrCb, cb) {
+        const command = new AdminLinkProviderForUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminListDevices = function (args, optionsOrCb, cb) {
-        var command = new AdminListDevicesCommand(args);
+    }
+    adminListDevices(args, optionsOrCb, cb) {
+        const command = new AdminListDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminListGroupsForUser = function (args, optionsOrCb, cb) {
-        var command = new AdminListGroupsForUserCommand(args);
+    }
+    adminListGroupsForUser(args, optionsOrCb, cb) {
+        const command = new AdminListGroupsForUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminListUserAuthEvents = function (args, optionsOrCb, cb) {
-        var command = new AdminListUserAuthEventsCommand(args);
+    }
+    adminListUserAuthEvents(args, optionsOrCb, cb) {
+        const command = new AdminListUserAuthEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminRemoveUserFromGroup = function (args, optionsOrCb, cb) {
-        var command = new AdminRemoveUserFromGroupCommand(args);
+    }
+    adminRemoveUserFromGroup(args, optionsOrCb, cb) {
+        const command = new AdminRemoveUserFromGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminResetUserPassword = function (args, optionsOrCb, cb) {
-        var command = new AdminResetUserPasswordCommand(args);
+    }
+    adminResetUserPassword(args, optionsOrCb, cb) {
+        const command = new AdminResetUserPasswordCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminRespondToAuthChallenge = function (args, optionsOrCb, cb) {
-        var command = new AdminRespondToAuthChallengeCommand(args);
+    }
+    adminRespondToAuthChallenge(args, optionsOrCb, cb) {
+        const command = new AdminRespondToAuthChallengeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminSetUserMFAPreference = function (args, optionsOrCb, cb) {
-        var command = new AdminSetUserMFAPreferenceCommand(args);
+    }
+    adminSetUserMFAPreference(args, optionsOrCb, cb) {
+        const command = new AdminSetUserMFAPreferenceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminSetUserPassword = function (args, optionsOrCb, cb) {
-        var command = new AdminSetUserPasswordCommand(args);
+    }
+    adminSetUserPassword(args, optionsOrCb, cb) {
+        const command = new AdminSetUserPasswordCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminSetUserSettings = function (args, optionsOrCb, cb) {
-        var command = new AdminSetUserSettingsCommand(args);
+    }
+    adminSetUserSettings(args, optionsOrCb, cb) {
+        const command = new AdminSetUserSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminUpdateAuthEventFeedback = function (args, optionsOrCb, cb) {
-        var command = new AdminUpdateAuthEventFeedbackCommand(args);
+    }
+    adminUpdateAuthEventFeedback(args, optionsOrCb, cb) {
+        const command = new AdminUpdateAuthEventFeedbackCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminUpdateDeviceStatus = function (args, optionsOrCb, cb) {
-        var command = new AdminUpdateDeviceStatusCommand(args);
+    }
+    adminUpdateDeviceStatus(args, optionsOrCb, cb) {
+        const command = new AdminUpdateDeviceStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminUpdateUserAttributes = function (args, optionsOrCb, cb) {
-        var command = new AdminUpdateUserAttributesCommand(args);
+    }
+    adminUpdateUserAttributes(args, optionsOrCb, cb) {
+        const command = new AdminUpdateUserAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.adminUserGlobalSignOut = function (args, optionsOrCb, cb) {
-        var command = new AdminUserGlobalSignOutCommand(args);
+    }
+    adminUserGlobalSignOut(args, optionsOrCb, cb) {
+        const command = new AdminUserGlobalSignOutCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.associateSoftwareToken = function (args, optionsOrCb, cb) {
-        var command = new AssociateSoftwareTokenCommand(args);
+    }
+    associateSoftwareToken(args, optionsOrCb, cb) {
+        const command = new AssociateSoftwareTokenCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.changePassword = function (args, optionsOrCb, cb) {
-        var command = new ChangePasswordCommand(args);
+    }
+    changePassword(args, optionsOrCb, cb) {
+        const 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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.confirmDevice = function (args, optionsOrCb, cb) {
-        var command = new ConfirmDeviceCommand(args);
+    }
+    confirmDevice(args, optionsOrCb, cb) {
+        const command = new ConfirmDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.confirmForgotPassword = function (args, optionsOrCb, cb) {
-        var command = new ConfirmForgotPasswordCommand(args);
+    }
+    confirmForgotPassword(args, optionsOrCb, cb) {
+        const command = new ConfirmForgotPasswordCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.confirmSignUp = function (args, optionsOrCb, cb) {
-        var command = new ConfirmSignUpCommand(args);
+    }
+    confirmSignUp(args, optionsOrCb, cb) {
+        const command = new ConfirmSignUpCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.createGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateGroupCommand(args);
+    }
+    createGroup(args, optionsOrCb, cb) {
+        const command = new CreateGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.createIdentityProvider = function (args, optionsOrCb, cb) {
-        var command = new CreateIdentityProviderCommand(args);
+    }
+    createIdentityProvider(args, optionsOrCb, cb) {
+        const command = new CreateIdentityProviderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.createResourceServer = function (args, optionsOrCb, cb) {
-        var command = new CreateResourceServerCommand(args);
+    }
+    createResourceServer(args, optionsOrCb, cb) {
+        const command = new CreateResourceServerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.createUserImportJob = function (args, optionsOrCb, cb) {
-        var command = new CreateUserImportJobCommand(args);
+    }
+    createUserImportJob(args, optionsOrCb, cb) {
+        const command = new CreateUserImportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.createUserPool = function (args, optionsOrCb, cb) {
-        var command = new CreateUserPoolCommand(args);
+    }
+    createUserPool(args, optionsOrCb, cb) {
+        const command = new CreateUserPoolCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.createUserPoolClient = function (args, optionsOrCb, cb) {
-        var command = new CreateUserPoolClientCommand(args);
+    }
+    createUserPoolClient(args, optionsOrCb, cb) {
+        const command = new CreateUserPoolClientCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.createUserPoolDomain = function (args, optionsOrCb, cb) {
-        var command = new CreateUserPoolDomainCommand(args);
+    }
+    createUserPoolDomain(args, optionsOrCb, cb) {
+        const command = new CreateUserPoolDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.deleteGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteGroupCommand(args);
+    }
+    deleteGroup(args, optionsOrCb, cb) {
+        const command = new DeleteGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.deleteIdentityProvider = function (args, optionsOrCb, cb) {
-        var command = new DeleteIdentityProviderCommand(args);
+    }
+    deleteIdentityProvider(args, optionsOrCb, cb) {
+        const command = new DeleteIdentityProviderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.deleteResourceServer = function (args, optionsOrCb, cb) {
-        var command = new DeleteResourceServerCommand(args);
+    }
+    deleteResourceServer(args, optionsOrCb, cb) {
+        const command = new DeleteResourceServerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.deleteUser = function (args, optionsOrCb, cb) {
-        var command = new DeleteUserCommand(args);
+    }
+    deleteUser(args, optionsOrCb, cb) {
+        const 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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.deleteUserAttributes = function (args, optionsOrCb, cb) {
-        var command = new DeleteUserAttributesCommand(args);
+    }
+    deleteUserAttributes(args, optionsOrCb, cb) {
+        const command = new DeleteUserAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.deleteUserPool = function (args, optionsOrCb, cb) {
-        var command = new DeleteUserPoolCommand(args);
+    }
+    deleteUserPool(args, optionsOrCb, cb) {
+        const command = new DeleteUserPoolCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.deleteUserPoolClient = function (args, optionsOrCb, cb) {
-        var command = new DeleteUserPoolClientCommand(args);
+    }
+    deleteUserPoolClient(args, optionsOrCb, cb) {
+        const command = new DeleteUserPoolClientCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.deleteUserPoolDomain = function (args, optionsOrCb, cb) {
-        var command = new DeleteUserPoolDomainCommand(args);
+    }
+    deleteUserPoolDomain(args, optionsOrCb, cb) {
+        const command = new DeleteUserPoolDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.describeIdentityProvider = function (args, optionsOrCb, cb) {
-        var command = new DescribeIdentityProviderCommand(args);
+    }
+    describeIdentityProvider(args, optionsOrCb, cb) {
+        const command = new DescribeIdentityProviderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.describeResourceServer = function (args, optionsOrCb, cb) {
-        var command = new DescribeResourceServerCommand(args);
+    }
+    describeResourceServer(args, optionsOrCb, cb) {
+        const command = new DescribeResourceServerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.describeRiskConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DescribeRiskConfigurationCommand(args);
+    }
+    describeRiskConfiguration(args, optionsOrCb, cb) {
+        const command = new DescribeRiskConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.describeUserImportJob = function (args, optionsOrCb, cb) {
-        var command = new DescribeUserImportJobCommand(args);
+    }
+    describeUserImportJob(args, optionsOrCb, cb) {
+        const command = new DescribeUserImportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.describeUserPool = function (args, optionsOrCb, cb) {
-        var command = new DescribeUserPoolCommand(args);
+    }
+    describeUserPool(args, optionsOrCb, cb) {
+        const command = new DescribeUserPoolCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.describeUserPoolClient = function (args, optionsOrCb, cb) {
-        var command = new DescribeUserPoolClientCommand(args);
+    }
+    describeUserPoolClient(args, optionsOrCb, cb) {
+        const command = new DescribeUserPoolClientCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.describeUserPoolDomain = function (args, optionsOrCb, cb) {
-        var command = new DescribeUserPoolDomainCommand(args);
+    }
+    describeUserPoolDomain(args, optionsOrCb, cb) {
+        const command = new DescribeUserPoolDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.forgetDevice = function (args, optionsOrCb, cb) {
-        var command = new ForgetDeviceCommand(args);
+    }
+    forgetDevice(args, optionsOrCb, cb) {
+        const command = new ForgetDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.forgotPassword = function (args, optionsOrCb, cb) {
-        var command = new ForgotPasswordCommand(args);
+    }
+    forgotPassword(args, optionsOrCb, cb) {
+        const command = new ForgotPasswordCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getCSVHeader = function (args, optionsOrCb, cb) {
-        var command = new GetCSVHeaderCommand(args);
+    }
+    getCSVHeader(args, optionsOrCb, cb) {
+        const command = new GetCSVHeaderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getDevice = function (args, optionsOrCb, cb) {
-        var command = new GetDeviceCommand(args);
+    }
+    getDevice(args, optionsOrCb, cb) {
+        const command = new GetDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getGroup = function (args, optionsOrCb, cb) {
-        var command = new GetGroupCommand(args);
+    }
+    getGroup(args, optionsOrCb, cb) {
+        const command = new GetGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getIdentityProviderByIdentifier = function (args, optionsOrCb, cb) {
-        var command = new GetIdentityProviderByIdentifierCommand(args);
+    }
+    getIdentityProviderByIdentifier(args, optionsOrCb, cb) {
+        const command = new GetIdentityProviderByIdentifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getSigningCertificate = function (args, optionsOrCb, cb) {
-        var command = new GetSigningCertificateCommand(args);
+    }
+    getSigningCertificate(args, optionsOrCb, cb) {
+        const command = new GetSigningCertificateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getUICustomization = function (args, optionsOrCb, cb) {
-        var command = new GetUICustomizationCommand(args);
+    }
+    getUICustomization(args, optionsOrCb, cb) {
+        const command = new GetUICustomizationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getUser = function (args, optionsOrCb, cb) {
-        var command = new GetUserCommand(args);
+    }
+    getUser(args, optionsOrCb, cb) {
+        const 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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getUserAttributeVerificationCode = function (args, optionsOrCb, cb) {
-        var command = new GetUserAttributeVerificationCodeCommand(args);
+    }
+    getUserAttributeVerificationCode(args, optionsOrCb, cb) {
+        const command = new GetUserAttributeVerificationCodeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.getUserPoolMfaConfig = function (args, optionsOrCb, cb) {
-        var command = new GetUserPoolMfaConfigCommand(args);
+    }
+    getUserPoolMfaConfig(args, optionsOrCb, cb) {
+        const command = new GetUserPoolMfaConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.globalSignOut = function (args, optionsOrCb, cb) {
-        var command = new GlobalSignOutCommand(args);
+    }
+    globalSignOut(args, optionsOrCb, cb) {
+        const command = new GlobalSignOutCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.initiateAuth = function (args, optionsOrCb, cb) {
-        var command = new InitiateAuthCommand(args);
+    }
+    initiateAuth(args, optionsOrCb, cb) {
+        const command = new InitiateAuthCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listDevices = function (args, optionsOrCb, cb) {
-        var command = new ListDevicesCommand(args);
+    }
+    listDevices(args, optionsOrCb, cb) {
+        const command = new ListDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listGroups = function (args, optionsOrCb, cb) {
-        var command = new ListGroupsCommand(args);
+    }
+    listGroups(args, optionsOrCb, cb) {
+        const command = new ListGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listIdentityProviders = function (args, optionsOrCb, cb) {
-        var command = new ListIdentityProvidersCommand(args);
+    }
+    listIdentityProviders(args, optionsOrCb, cb) {
+        const command = new ListIdentityProvidersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listResourceServers = function (args, optionsOrCb, cb) {
-        var command = new ListResourceServersCommand(args);
+    }
+    listResourceServers(args, optionsOrCb, cb) {
+        const command = new ListResourceServersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listUserImportJobs = function (args, optionsOrCb, cb) {
-        var command = new ListUserImportJobsCommand(args);
+    }
+    listUserImportJobs(args, optionsOrCb, cb) {
+        const command = new ListUserImportJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listUserPoolClients = function (args, optionsOrCb, cb) {
-        var command = new ListUserPoolClientsCommand(args);
+    }
+    listUserPoolClients(args, optionsOrCb, cb) {
+        const command = new ListUserPoolClientsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listUserPools = function (args, optionsOrCb, cb) {
-        var command = new ListUserPoolsCommand(args);
+    }
+    listUserPools(args, optionsOrCb, cb) {
+        const command = new ListUserPoolsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listUsers = function (args, optionsOrCb, cb) {
-        var command = new ListUsersCommand(args);
+    }
+    listUsers(args, optionsOrCb, cb) {
+        const 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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.listUsersInGroup = function (args, optionsOrCb, cb) {
-        var command = new ListUsersInGroupCommand(args);
+    }
+    listUsersInGroup(args, optionsOrCb, cb) {
+        const command = new ListUsersInGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.resendConfirmationCode = function (args, optionsOrCb, cb) {
-        var command = new ResendConfirmationCodeCommand(args);
+    }
+    resendConfirmationCode(args, optionsOrCb, cb) {
+        const command = new ResendConfirmationCodeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.respondToAuthChallenge = function (args, optionsOrCb, cb) {
-        var command = new RespondToAuthChallengeCommand(args);
+    }
+    respondToAuthChallenge(args, optionsOrCb, cb) {
+        const command = new RespondToAuthChallengeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.revokeToken = function (args, optionsOrCb, cb) {
-        var command = new RevokeTokenCommand(args);
+    }
+    revokeToken(args, optionsOrCb, cb) {
+        const command = new RevokeTokenCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.setRiskConfiguration = function (args, optionsOrCb, cb) {
-        var command = new SetRiskConfigurationCommand(args);
+    }
+    setRiskConfiguration(args, optionsOrCb, cb) {
+        const command = new SetRiskConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.setUICustomization = function (args, optionsOrCb, cb) {
-        var command = new SetUICustomizationCommand(args);
+    }
+    setUICustomization(args, optionsOrCb, cb) {
+        const command = new SetUICustomizationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.setUserMFAPreference = function (args, optionsOrCb, cb) {
-        var command = new SetUserMFAPreferenceCommand(args);
+    }
+    setUserMFAPreference(args, optionsOrCb, cb) {
+        const command = new SetUserMFAPreferenceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.setUserPoolMfaConfig = function (args, optionsOrCb, cb) {
-        var command = new SetUserPoolMfaConfigCommand(args);
+    }
+    setUserPoolMfaConfig(args, optionsOrCb, cb) {
+        const command = new SetUserPoolMfaConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.setUserSettings = function (args, optionsOrCb, cb) {
-        var command = new SetUserSettingsCommand(args);
+    }
+    setUserSettings(args, optionsOrCb, cb) {
+        const command = new SetUserSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.signUp = function (args, optionsOrCb, cb) {
-        var command = new SignUpCommand(args);
+    }
+    signUp(args, optionsOrCb, cb) {
+        const command = new SignUpCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.startUserImportJob = function (args, optionsOrCb, cb) {
-        var command = new StartUserImportJobCommand(args);
+    }
+    startUserImportJob(args, optionsOrCb, cb) {
+        const command = new StartUserImportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.stopUserImportJob = function (args, optionsOrCb, cb) {
-        var command = new StopUserImportJobCommand(args);
+    }
+    stopUserImportJob(args, optionsOrCb, cb) {
+        const command = new StopUserImportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateAuthEventFeedback = function (args, optionsOrCb, cb) {
-        var command = new UpdateAuthEventFeedbackCommand(args);
+    }
+    updateAuthEventFeedback(args, optionsOrCb, cb) {
+        const command = new UpdateAuthEventFeedbackCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateDeviceStatus = function (args, optionsOrCb, cb) {
-        var command = new UpdateDeviceStatusCommand(args);
+    }
+    updateDeviceStatus(args, optionsOrCb, cb) {
+        const command = new UpdateDeviceStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateGroup = function (args, optionsOrCb, cb) {
-        var command = new UpdateGroupCommand(args);
+    }
+    updateGroup(args, optionsOrCb, cb) {
+        const command = new UpdateGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateIdentityProvider = function (args, optionsOrCb, cb) {
-        var command = new UpdateIdentityProviderCommand(args);
+    }
+    updateIdentityProvider(args, optionsOrCb, cb) {
+        const command = new UpdateIdentityProviderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateResourceServer = function (args, optionsOrCb, cb) {
-        var command = new UpdateResourceServerCommand(args);
+    }
+    updateResourceServer(args, optionsOrCb, cb) {
+        const command = new UpdateResourceServerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateUserAttributes = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserAttributesCommand(args);
+    }
+    updateUserAttributes(args, optionsOrCb, cb) {
+        const command = new UpdateUserAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateUserPool = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserPoolCommand(args);
+    }
+    updateUserPool(args, optionsOrCb, cb) {
+        const command = new UpdateUserPoolCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateUserPoolClient = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserPoolClientCommand(args);
+    }
+    updateUserPoolClient(args, optionsOrCb, cb) {
+        const command = new UpdateUserPoolClientCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.updateUserPoolDomain = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserPoolDomainCommand(args);
+    }
+    updateUserPoolDomain(args, optionsOrCb, cb) {
+        const command = new UpdateUserPoolDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.verifySoftwareToken = function (args, optionsOrCb, cb) {
-        var command = new VerifySoftwareTokenCommand(args);
+    }
+    verifySoftwareToken(args, optionsOrCb, cb) {
+        const command = new VerifySoftwareTokenCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CognitoIdentityProvider.prototype.verifyUserAttribute = function (args, optionsOrCb, cb) {
-        var command = new VerifyUserAttributeCommand(args);
+    }
+    verifyUserAttribute(args, optionsOrCb, cb) {
+        const command = new VerifyUserAttributeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return CognitoIdentityProvider;
-}(CognitoIdentityProviderClient));
-export { CognitoIdentityProvider };
+    }
+}