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

package/dist-es/commands/AdminResetUserPasswordCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminResetUserPasswordRequestFilterSensitiveLog, AdminResetUserPasswordResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminResetUserPasswordCommand, serializeAws_json1_1AdminResetUserPasswordCommand, } from "../protocols/Aws_json1_1";
-export class AdminResetUserPasswordCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminResetUserPasswordCommand = (function (_super) {
+    __extends(AdminResetUserPasswordCommand, _super);
+    function AdminResetUserPasswordCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminResetUserPasswordCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminResetUserPasswordCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminResetUserPasswordCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminResetUserPasswordRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminResetUserPasswordResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminResetUserPasswordCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminResetUserPasswordCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminResetUserPasswordCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminResetUserPasswordCommand(output, context);
-    }
-}
+    };
+    return AdminResetUserPasswordCommand;
+}($Command));
+export { AdminResetUserPasswordCommand };

package/dist-es/commands/AdminRespondToAuthChallengeCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminRespondToAuthChallengeRequestFilterSensitiveLog, AdminRespondToAuthChallengeResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminRespondToAuthChallengeCommand, serializeAws_json1_1AdminRespondToAuthChallengeCommand, } from "../protocols/Aws_json1_1";
-export class AdminRespondToAuthChallengeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminRespondToAuthChallengeCommand = (function (_super) {
+    __extends(AdminRespondToAuthChallengeCommand, _super);
+    function AdminRespondToAuthChallengeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminRespondToAuthChallengeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminRespondToAuthChallengeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminRespondToAuthChallengeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminRespondToAuthChallengeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminRespondToAuthChallengeResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminRespondToAuthChallengeCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminRespondToAuthChallengeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminRespondToAuthChallengeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminRespondToAuthChallengeCommand(output, context);
-    }
-}
+    };
+    return AdminRespondToAuthChallengeCommand;
+}($Command));
+export { AdminRespondToAuthChallengeCommand };

package/dist-es/commands/AdminSetUserMFAPreferenceCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminSetUserMFAPreferenceRequestFilterSensitiveLog, AdminSetUserMFAPreferenceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminSetUserMFAPreferenceCommand, serializeAws_json1_1AdminSetUserMFAPreferenceCommand, } from "../protocols/Aws_json1_1";
-export class AdminSetUserMFAPreferenceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminSetUserMFAPreferenceCommand = (function (_super) {
+    __extends(AdminSetUserMFAPreferenceCommand, _super);
+    function AdminSetUserMFAPreferenceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminSetUserMFAPreferenceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminSetUserMFAPreferenceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminSetUserMFAPreferenceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminSetUserMFAPreferenceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminSetUserMFAPreferenceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminSetUserMFAPreferenceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminSetUserMFAPreferenceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminSetUserMFAPreferenceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminSetUserMFAPreferenceCommand(output, context);
-    }
-}
+    };
+    return AdminSetUserMFAPreferenceCommand;
+}($Command));
+export { AdminSetUserMFAPreferenceCommand };

package/dist-es/commands/AdminSetUserPasswordCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminSetUserPasswordRequestFilterSensitiveLog, AdminSetUserPasswordResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminSetUserPasswordCommand, serializeAws_json1_1AdminSetUserPasswordCommand, } from "../protocols/Aws_json1_1";
-export class AdminSetUserPasswordCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminSetUserPasswordCommand = (function (_super) {
+    __extends(AdminSetUserPasswordCommand, _super);
+    function AdminSetUserPasswordCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminSetUserPasswordCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminSetUserPasswordCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminSetUserPasswordCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminSetUserPasswordRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminSetUserPasswordResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminSetUserPasswordCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminSetUserPasswordCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminSetUserPasswordCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminSetUserPasswordCommand(output, context);
-    }
-}
+    };
+    return AdminSetUserPasswordCommand;
+}($Command));
+export { AdminSetUserPasswordCommand };

package/dist-es/commands/AdminSetUserSettingsCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminSetUserSettingsRequestFilterSensitiveLog, AdminSetUserSettingsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminSetUserSettingsCommand, serializeAws_json1_1AdminSetUserSettingsCommand, } from "../protocols/Aws_json1_1";
-export class AdminSetUserSettingsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminSetUserSettingsCommand = (function (_super) {
+    __extends(AdminSetUserSettingsCommand, _super);
+    function AdminSetUserSettingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminSetUserSettingsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminSetUserSettingsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminSetUserSettingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminSetUserSettingsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminSetUserSettingsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminSetUserSettingsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminSetUserSettingsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminSetUserSettingsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminSetUserSettingsCommand(output, context);
-    }
-}
+    };
+    return AdminSetUserSettingsCommand;
+}($Command));
+export { AdminSetUserSettingsCommand };

package/dist-es/commands/AdminUpdateAuthEventFeedbackCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminUpdateAuthEventFeedbackRequestFilterSensitiveLog, AdminUpdateAuthEventFeedbackResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminUpdateAuthEventFeedbackCommand, serializeAws_json1_1AdminUpdateAuthEventFeedbackCommand, } from "../protocols/Aws_json1_1";
-export class AdminUpdateAuthEventFeedbackCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminUpdateAuthEventFeedbackCommand = (function (_super) {
+    __extends(AdminUpdateAuthEventFeedbackCommand, _super);
+    function AdminUpdateAuthEventFeedbackCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminUpdateAuthEventFeedbackCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminUpdateAuthEventFeedbackCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminUpdateAuthEventFeedbackCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminUpdateAuthEventFeedbackRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminUpdateAuthEventFeedbackResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminUpdateAuthEventFeedbackCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminUpdateAuthEventFeedbackCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminUpdateAuthEventFeedbackCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminUpdateAuthEventFeedbackCommand(output, context);
-    }
-}
+    };
+    return AdminUpdateAuthEventFeedbackCommand;
+}($Command));
+export { AdminUpdateAuthEventFeedbackCommand };

package/dist-es/commands/AdminUpdateDeviceStatusCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminUpdateDeviceStatusRequestFilterSensitiveLog, AdminUpdateDeviceStatusResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminUpdateDeviceStatusCommand, serializeAws_json1_1AdminUpdateDeviceStatusCommand, } from "../protocols/Aws_json1_1";
-export class AdminUpdateDeviceStatusCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminUpdateDeviceStatusCommand = (function (_super) {
+    __extends(AdminUpdateDeviceStatusCommand, _super);
+    function AdminUpdateDeviceStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminUpdateDeviceStatusCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminUpdateDeviceStatusCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminUpdateDeviceStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminUpdateDeviceStatusRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminUpdateDeviceStatusResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminUpdateDeviceStatusCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminUpdateDeviceStatusCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminUpdateDeviceStatusCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminUpdateDeviceStatusCommand(output, context);
-    }
-}
+    };
+    return AdminUpdateDeviceStatusCommand;
+}($Command));
+export { AdminUpdateDeviceStatusCommand };

package/dist-es/commands/AdminUpdateUserAttributesCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminUpdateUserAttributesRequestFilterSensitiveLog, AdminUpdateUserAttributesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminUpdateUserAttributesCommand, serializeAws_json1_1AdminUpdateUserAttributesCommand, } from "../protocols/Aws_json1_1";
-export class AdminUpdateUserAttributesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminUpdateUserAttributesCommand = (function (_super) {
+    __extends(AdminUpdateUserAttributesCommand, _super);
+    function AdminUpdateUserAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminUpdateUserAttributesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminUpdateUserAttributesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminUpdateUserAttributesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminUpdateUserAttributesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminUpdateUserAttributesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminUpdateUserAttributesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminUpdateUserAttributesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminUpdateUserAttributesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminUpdateUserAttributesCommand(output, context);
-    }
-}
+    };
+    return AdminUpdateUserAttributesCommand;
+}($Command));
+export { AdminUpdateUserAttributesCommand };

package/dist-es/commands/AdminUserGlobalSignOutCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdminUserGlobalSignOutRequestFilterSensitiveLog, AdminUserGlobalSignOutResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AdminUserGlobalSignOutCommand, serializeAws_json1_1AdminUserGlobalSignOutCommand, } from "../protocols/Aws_json1_1";
-export class AdminUserGlobalSignOutCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AdminUserGlobalSignOutCommand = (function (_super) {
+    __extends(AdminUserGlobalSignOutCommand, _super);
+    function AdminUserGlobalSignOutCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AdminUserGlobalSignOutCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminUserGlobalSignOutCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "AdminUserGlobalSignOutCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AdminUserGlobalSignOutRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AdminUserGlobalSignOutResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AdminUserGlobalSignOutCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AdminUserGlobalSignOutCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AdminUserGlobalSignOutCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AdminUserGlobalSignOutCommand(output, context);
-    }
-}
+    };
+    return AdminUserGlobalSignOutCommand;
+}($Command));
+export { AdminUserGlobalSignOutCommand };