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

package/dist-es/CognitoIdentityProvider.js

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