@aws-sdk/client-cognito-identity-provider 3.32.0 → 3.36.0

package/dist-es/commands/ConfirmDeviceCommand.js

@@ -0,0 +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 { ConfirmDeviceRequest, ConfirmDeviceResponse } from "../models/models_0";
+import { deserializeAws_json1_1ConfirmDeviceCommand, serializeAws_json1_1ConfirmDeviceCommand, } from "../protocols/Aws_json1_1";
+var ConfirmDeviceCommand = (function (_super) {
+    __extends(ConfirmDeviceCommand, _super);
+    function ConfirmDeviceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ConfirmDeviceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "ConfirmDeviceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ConfirmDeviceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ConfirmDeviceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ConfirmDeviceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ConfirmDeviceCommand(input, context);
+    };
+    ConfirmDeviceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ConfirmDeviceCommand(output, context);
+    };
+    return ConfirmDeviceCommand;
+}($Command));
+export { ConfirmDeviceCommand };

package/dist-es/commands/ConfirmForgotPasswordCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ConfirmForgotPasswordRequest, ConfirmForgotPasswordResponse } from "../models/models_0";
+import { deserializeAws_json1_1ConfirmForgotPasswordCommand, serializeAws_json1_1ConfirmForgotPasswordCommand, } from "../protocols/Aws_json1_1";
+var ConfirmForgotPasswordCommand = (function (_super) {
+    __extends(ConfirmForgotPasswordCommand, _super);
+    function ConfirmForgotPasswordCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ConfirmForgotPasswordCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "ConfirmForgotPasswordCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ConfirmForgotPasswordRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ConfirmForgotPasswordResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ConfirmForgotPasswordCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ConfirmForgotPasswordCommand(input, context);
+    };
+    ConfirmForgotPasswordCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ConfirmForgotPasswordCommand(output, context);
+    };
+    return ConfirmForgotPasswordCommand;
+}($Command));
+export { ConfirmForgotPasswordCommand };

package/dist-es/commands/ConfirmSignUpCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ConfirmSignUpRequest, ConfirmSignUpResponse } from "../models/models_0";
+import { deserializeAws_json1_1ConfirmSignUpCommand, serializeAws_json1_1ConfirmSignUpCommand, } from "../protocols/Aws_json1_1";
+var ConfirmSignUpCommand = (function (_super) {
+    __extends(ConfirmSignUpCommand, _super);
+    function ConfirmSignUpCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ConfirmSignUpCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "ConfirmSignUpCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ConfirmSignUpRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ConfirmSignUpResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ConfirmSignUpCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ConfirmSignUpCommand(input, context);
+    };
+    ConfirmSignUpCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ConfirmSignUpCommand(output, context);
+    };
+    return ConfirmSignUpCommand;
+}($Command));
+export { ConfirmSignUpCommand };

package/dist-es/commands/CreateGroupCommand.js

@@ -0,0 +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 { CreateGroupRequest, CreateGroupResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateGroupCommand, serializeAws_json1_1CreateGroupCommand, } from "../protocols/Aws_json1_1";
+var CreateGroupCommand = (function (_super) {
+    __extends(CreateGroupCommand, _super);
+    function CreateGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "CreateGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateGroupCommand(input, context);
+    };
+    CreateGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateGroupCommand(output, context);
+    };
+    return CreateGroupCommand;
+}($Command));
+export { CreateGroupCommand };

package/dist-es/commands/CreateIdentityProviderCommand.js

@@ -0,0 +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 { CreateIdentityProviderRequest, CreateIdentityProviderResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateIdentityProviderCommand, serializeAws_json1_1CreateIdentityProviderCommand, } from "../protocols/Aws_json1_1";
+var CreateIdentityProviderCommand = (function (_super) {
+    __extends(CreateIdentityProviderCommand, _super);
+    function CreateIdentityProviderCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateIdentityProviderCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "CreateIdentityProviderCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateIdentityProviderRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateIdentityProviderResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateIdentityProviderCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateIdentityProviderCommand(input, context);
+    };
+    CreateIdentityProviderCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateIdentityProviderCommand(output, context);
+    };
+    return CreateIdentityProviderCommand;
+}($Command));
+export { CreateIdentityProviderCommand };

package/dist-es/commands/CreateResourceServerCommand.js

@@ -0,0 +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 { CreateResourceServerRequest, CreateResourceServerResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateResourceServerCommand, serializeAws_json1_1CreateResourceServerCommand, } from "../protocols/Aws_json1_1";
+var CreateResourceServerCommand = (function (_super) {
+    __extends(CreateResourceServerCommand, _super);
+    function CreateResourceServerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateResourceServerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "CreateResourceServerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateResourceServerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateResourceServerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateResourceServerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateResourceServerCommand(input, context);
+    };
+    CreateResourceServerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateResourceServerCommand(output, context);
+    };
+    return CreateResourceServerCommand;
+}($Command));
+export { CreateResourceServerCommand };

package/dist-es/commands/CreateUserImportJobCommand.js

@@ -0,0 +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 { CreateUserImportJobRequest, CreateUserImportJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateUserImportJobCommand, serializeAws_json1_1CreateUserImportJobCommand, } from "../protocols/Aws_json1_1";
+var CreateUserImportJobCommand = (function (_super) {
+    __extends(CreateUserImportJobCommand, _super);
+    function CreateUserImportJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateUserImportJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "CreateUserImportJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateUserImportJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateUserImportJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateUserImportJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateUserImportJobCommand(input, context);
+    };
+    CreateUserImportJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateUserImportJobCommand(output, context);
+    };
+    return CreateUserImportJobCommand;
+}($Command));
+export { CreateUserImportJobCommand };

package/dist-es/commands/CreateUserPoolClientCommand.js

@@ -0,0 +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 { CreateUserPoolClientRequest, CreateUserPoolClientResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateUserPoolClientCommand, serializeAws_json1_1CreateUserPoolClientCommand, } from "../protocols/Aws_json1_1";
+var CreateUserPoolClientCommand = (function (_super) {
+    __extends(CreateUserPoolClientCommand, _super);
+    function CreateUserPoolClientCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateUserPoolClientCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "CreateUserPoolClientCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateUserPoolClientRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateUserPoolClientResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateUserPoolClientCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateUserPoolClientCommand(input, context);
+    };
+    CreateUserPoolClientCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateUserPoolClientCommand(output, context);
+    };
+    return CreateUserPoolClientCommand;
+}($Command));
+export { CreateUserPoolClientCommand };

package/dist-es/commands/CreateUserPoolCommand.js

@@ -0,0 +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 { CreateUserPoolRequest, CreateUserPoolResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateUserPoolCommand, serializeAws_json1_1CreateUserPoolCommand, } from "../protocols/Aws_json1_1";
+var CreateUserPoolCommand = (function (_super) {
+    __extends(CreateUserPoolCommand, _super);
+    function CreateUserPoolCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateUserPoolCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "CreateUserPoolCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateUserPoolRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateUserPoolResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateUserPoolCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateUserPoolCommand(input, context);
+    };
+    CreateUserPoolCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateUserPoolCommand(output, context);
+    };
+    return CreateUserPoolCommand;
+}($Command));
+export { CreateUserPoolCommand };

package/dist-es/commands/CreateUserPoolDomainCommand.js

@@ -0,0 +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 { CreateUserPoolDomainRequest, CreateUserPoolDomainResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateUserPoolDomainCommand, serializeAws_json1_1CreateUserPoolDomainCommand, } from "../protocols/Aws_json1_1";
+var CreateUserPoolDomainCommand = (function (_super) {
+    __extends(CreateUserPoolDomainCommand, _super);
+    function CreateUserPoolDomainCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateUserPoolDomainCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "CreateUserPoolDomainCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateUserPoolDomainRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateUserPoolDomainResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateUserPoolDomainCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateUserPoolDomainCommand(input, context);
+    };
+    CreateUserPoolDomainCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateUserPoolDomainCommand(output, context);
+    };
+    return CreateUserPoolDomainCommand;
+}($Command));
+export { CreateUserPoolDomainCommand };

package/dist-es/commands/DeleteGroupCommand.js

@@ -0,0 +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 { DeleteGroupRequest } from "../models/models_0";
+import { deserializeAws_json1_1DeleteGroupCommand, serializeAws_json1_1DeleteGroupCommand, } from "../protocols/Aws_json1_1";
+var DeleteGroupCommand = (function (_super) {
+    __extends(DeleteGroupCommand, _super);
+    function DeleteGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "DeleteGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteGroupCommand(input, context);
+    };
+    DeleteGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteGroupCommand(output, context);
+    };
+    return DeleteGroupCommand;
+}($Command));
+export { DeleteGroupCommand };

package/dist-es/commands/DeleteIdentityProviderCommand.js

@@ -0,0 +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 { DeleteIdentityProviderRequest } from "../models/models_0";
+import { deserializeAws_json1_1DeleteIdentityProviderCommand, serializeAws_json1_1DeleteIdentityProviderCommand, } from "../protocols/Aws_json1_1";
+var DeleteIdentityProviderCommand = (function (_super) {
+    __extends(DeleteIdentityProviderCommand, _super);
+    function DeleteIdentityProviderCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteIdentityProviderCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "DeleteIdentityProviderCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteIdentityProviderRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteIdentityProviderCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteIdentityProviderCommand(input, context);
+    };
+    DeleteIdentityProviderCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteIdentityProviderCommand(output, context);
+    };
+    return DeleteIdentityProviderCommand;
+}($Command));
+export { DeleteIdentityProviderCommand };

package/dist-es/commands/DeleteResourceServerCommand.js

@@ -0,0 +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 { DeleteResourceServerRequest } from "../models/models_0";
+import { deserializeAws_json1_1DeleteResourceServerCommand, serializeAws_json1_1DeleteResourceServerCommand, } from "../protocols/Aws_json1_1";
+var DeleteResourceServerCommand = (function (_super) {
+    __extends(DeleteResourceServerCommand, _super);
+    function DeleteResourceServerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteResourceServerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "DeleteResourceServerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteResourceServerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteResourceServerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteResourceServerCommand(input, context);
+    };
+    DeleteResourceServerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteResourceServerCommand(output, context);
+    };
+    return DeleteResourceServerCommand;
+}($Command));
+export { DeleteResourceServerCommand };

package/dist-es/commands/DeleteUserAttributesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteUserAttributesRequest, DeleteUserAttributesResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteUserAttributesCommand, serializeAws_json1_1DeleteUserAttributesCommand, } from "../protocols/Aws_json1_1";
+var DeleteUserAttributesCommand = (function (_super) {
+    __extends(DeleteUserAttributesCommand, _super);
+    function DeleteUserAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteUserAttributesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "DeleteUserAttributesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteUserAttributesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteUserAttributesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteUserAttributesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteUserAttributesCommand(input, context);
+    };
+    DeleteUserAttributesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteUserAttributesCommand(output, context);
+    };
+    return DeleteUserAttributesCommand;
+}($Command));
+export { DeleteUserAttributesCommand };

package/dist-es/commands/DeleteUserCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteUserRequest } from "../models/models_0";
+import { deserializeAws_json1_1DeleteUserCommand, serializeAws_json1_1DeleteUserCommand, } from "../protocols/Aws_json1_1";
+var DeleteUserCommand = (function (_super) {
+    __extends(DeleteUserCommand, _super);
+    function DeleteUserCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteUserCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CognitoIdentityProviderClient";
+        var commandName = "DeleteUserCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteUserRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteUserCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteUserCommand(input, context);
+    };
+    DeleteUserCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteUserCommand(output, context);
+    };
+    return DeleteUserCommand;
+}($Command));
+export { DeleteUserCommand };