serverless-spy 0.0.4 → 0.0.7

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/DescribeIdentityCommand.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 { DescribeIdentityInputFilterSensitiveLog, IdentityDescriptionFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1DescribeIdentityCommand, serializeAws_json1_1DescribeIdentityCommand, } from "../protocols/Aws_json1_1";
+var DescribeIdentityCommand = (function (_super) {
+    __extends(DescribeIdentityCommand, _super);
+    function DescribeIdentityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeIdentityCommand.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 = "CognitoIdentityClient";
+        var commandName = "DescribeIdentityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeIdentityInputFilterSensitiveLog,
+            outputFilterSensitiveLog: IdentityDescriptionFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeIdentityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeIdentityCommand(input, context);
+    };
+    DescribeIdentityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeIdentityCommand(output, context);
+    };
+    return DescribeIdentityCommand;
+}($Command));
+export { DescribeIdentityCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/DescribeIdentityPoolCommand.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 { DescribeIdentityPoolInputFilterSensitiveLog, IdentityPoolFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1DescribeIdentityPoolCommand, serializeAws_json1_1DescribeIdentityPoolCommand, } from "../protocols/Aws_json1_1";
+var DescribeIdentityPoolCommand = (function (_super) {
+    __extends(DescribeIdentityPoolCommand, _super);
+    function DescribeIdentityPoolCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeIdentityPoolCommand.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 = "CognitoIdentityClient";
+        var commandName = "DescribeIdentityPoolCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeIdentityPoolInputFilterSensitiveLog,
+            outputFilterSensitiveLog: IdentityPoolFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeIdentityPoolCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeIdentityPoolCommand(input, context);
+    };
+    DescribeIdentityPoolCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeIdentityPoolCommand(output, context);
+    };
+    return DescribeIdentityPoolCommand;
+}($Command));
+export { DescribeIdentityPoolCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/GetCredentialsForIdentityCommand.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 { GetCredentialsForIdentityInputFilterSensitiveLog, GetCredentialsForIdentityResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetCredentialsForIdentityCommand, serializeAws_json1_1GetCredentialsForIdentityCommand, } from "../protocols/Aws_json1_1";
+var GetCredentialsForIdentityCommand = (function (_super) {
+    __extends(GetCredentialsForIdentityCommand, _super);
+    function GetCredentialsForIdentityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetCredentialsForIdentityCommand.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 = "CognitoIdentityClient";
+        var commandName = "GetCredentialsForIdentityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetCredentialsForIdentityInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetCredentialsForIdentityResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetCredentialsForIdentityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetCredentialsForIdentityCommand(input, context);
+    };
+    GetCredentialsForIdentityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetCredentialsForIdentityCommand(output, context);
+    };
+    return GetCredentialsForIdentityCommand;
+}($Command));
+export { GetCredentialsForIdentityCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/GetIdCommand.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 { GetIdInputFilterSensitiveLog, GetIdResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetIdCommand, serializeAws_json1_1GetIdCommand } from "../protocols/Aws_json1_1";
+var GetIdCommand = (function (_super) {
+    __extends(GetIdCommand, _super);
+    function GetIdCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetIdCommand.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 = "CognitoIdentityClient";
+        var commandName = "GetIdCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetIdInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetIdResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetIdCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetIdCommand(input, context);
+    };
+    GetIdCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetIdCommand(output, context);
+    };
+    return GetIdCommand;
+}($Command));
+export { GetIdCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/GetIdentityPoolRolesCommand.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 { GetIdentityPoolRolesInputFilterSensitiveLog, GetIdentityPoolRolesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetIdentityPoolRolesCommand, serializeAws_json1_1GetIdentityPoolRolesCommand, } from "../protocols/Aws_json1_1";
+var GetIdentityPoolRolesCommand = (function (_super) {
+    __extends(GetIdentityPoolRolesCommand, _super);
+    function GetIdentityPoolRolesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetIdentityPoolRolesCommand.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 = "CognitoIdentityClient";
+        var commandName = "GetIdentityPoolRolesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetIdentityPoolRolesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetIdentityPoolRolesResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetIdentityPoolRolesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetIdentityPoolRolesCommand(input, context);
+    };
+    GetIdentityPoolRolesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetIdentityPoolRolesCommand(output, context);
+    };
+    return GetIdentityPoolRolesCommand;
+}($Command));
+export { GetIdentityPoolRolesCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/GetOpenIdTokenCommand.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 { GetOpenIdTokenInputFilterSensitiveLog, GetOpenIdTokenResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetOpenIdTokenCommand, serializeAws_json1_1GetOpenIdTokenCommand, } from "../protocols/Aws_json1_1";
+var GetOpenIdTokenCommand = (function (_super) {
+    __extends(GetOpenIdTokenCommand, _super);
+    function GetOpenIdTokenCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetOpenIdTokenCommand.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 = "CognitoIdentityClient";
+        var commandName = "GetOpenIdTokenCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetOpenIdTokenInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetOpenIdTokenResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetOpenIdTokenCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetOpenIdTokenCommand(input, context);
+    };
+    GetOpenIdTokenCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetOpenIdTokenCommand(output, context);
+    };
+    return GetOpenIdTokenCommand;
+}($Command));
+export { GetOpenIdTokenCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/GetOpenIdTokenForDeveloperIdentityCommand.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 { GetOpenIdTokenForDeveloperIdentityInputFilterSensitiveLog, GetOpenIdTokenForDeveloperIdentityResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetOpenIdTokenForDeveloperIdentityCommand, serializeAws_json1_1GetOpenIdTokenForDeveloperIdentityCommand, } from "../protocols/Aws_json1_1";
+var GetOpenIdTokenForDeveloperIdentityCommand = (function (_super) {
+    __extends(GetOpenIdTokenForDeveloperIdentityCommand, _super);
+    function GetOpenIdTokenForDeveloperIdentityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetOpenIdTokenForDeveloperIdentityCommand.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 = "CognitoIdentityClient";
+        var commandName = "GetOpenIdTokenForDeveloperIdentityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetOpenIdTokenForDeveloperIdentityInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetOpenIdTokenForDeveloperIdentityResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetOpenIdTokenForDeveloperIdentityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetOpenIdTokenForDeveloperIdentityCommand(input, context);
+    };
+    GetOpenIdTokenForDeveloperIdentityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetOpenIdTokenForDeveloperIdentityCommand(output, context);
+    };
+    return GetOpenIdTokenForDeveloperIdentityCommand;
+}($Command));
+export { GetOpenIdTokenForDeveloperIdentityCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/GetPrincipalTagAttributeMapCommand.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 { GetPrincipalTagAttributeMapInputFilterSensitiveLog, GetPrincipalTagAttributeMapResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetPrincipalTagAttributeMapCommand, serializeAws_json1_1GetPrincipalTagAttributeMapCommand, } from "../protocols/Aws_json1_1";
+var GetPrincipalTagAttributeMapCommand = (function (_super) {
+    __extends(GetPrincipalTagAttributeMapCommand, _super);
+    function GetPrincipalTagAttributeMapCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetPrincipalTagAttributeMapCommand.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 = "CognitoIdentityClient";
+        var commandName = "GetPrincipalTagAttributeMapCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetPrincipalTagAttributeMapInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetPrincipalTagAttributeMapResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetPrincipalTagAttributeMapCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetPrincipalTagAttributeMapCommand(input, context);
+    };
+    GetPrincipalTagAttributeMapCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetPrincipalTagAttributeMapCommand(output, context);
+    };
+    return GetPrincipalTagAttributeMapCommand;
+}($Command));
+export { GetPrincipalTagAttributeMapCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/ListIdentitiesCommand.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 { ListIdentitiesInputFilterSensitiveLog, ListIdentitiesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListIdentitiesCommand, serializeAws_json1_1ListIdentitiesCommand, } from "../protocols/Aws_json1_1";
+var ListIdentitiesCommand = (function (_super) {
+    __extends(ListIdentitiesCommand, _super);
+    function ListIdentitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListIdentitiesCommand.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 = "CognitoIdentityClient";
+        var commandName = "ListIdentitiesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListIdentitiesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListIdentitiesResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListIdentitiesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListIdentitiesCommand(input, context);
+    };
+    ListIdentitiesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListIdentitiesCommand(output, context);
+    };
+    return ListIdentitiesCommand;
+}($Command));
+export { ListIdentitiesCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/ListIdentityPoolsCommand.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 { ListIdentityPoolsInputFilterSensitiveLog, ListIdentityPoolsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListIdentityPoolsCommand, serializeAws_json1_1ListIdentityPoolsCommand, } from "../protocols/Aws_json1_1";
+var ListIdentityPoolsCommand = (function (_super) {
+    __extends(ListIdentityPoolsCommand, _super);
+    function ListIdentityPoolsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListIdentityPoolsCommand.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 = "CognitoIdentityClient";
+        var commandName = "ListIdentityPoolsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListIdentityPoolsInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListIdentityPoolsResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListIdentityPoolsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListIdentityPoolsCommand(input, context);
+    };
+    ListIdentityPoolsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListIdentityPoolsCommand(output, context);
+    };
+    return ListIdentityPoolsCommand;
+}($Command));
+export { ListIdentityPoolsCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/ListTagsForResourceCommand.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 { ListTagsForResourceInputFilterSensitiveLog, ListTagsForResourceResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListTagsForResourceCommand, serializeAws_json1_1ListTagsForResourceCommand, } from "../protocols/Aws_json1_1";
+var ListTagsForResourceCommand = (function (_super) {
+    __extends(ListTagsForResourceCommand, _super);
+    function ListTagsForResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListTagsForResourceCommand.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 = "CognitoIdentityClient";
+        var commandName = "ListTagsForResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListTagsForResourceInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListTagsForResourceResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListTagsForResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListTagsForResourceCommand(input, context);
+    };
+    ListTagsForResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListTagsForResourceCommand(output, context);
+    };
+    return ListTagsForResourceCommand;
+}($Command));
+export { ListTagsForResourceCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/LookupDeveloperIdentityCommand.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 { LookupDeveloperIdentityInputFilterSensitiveLog, LookupDeveloperIdentityResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1LookupDeveloperIdentityCommand, serializeAws_json1_1LookupDeveloperIdentityCommand, } from "../protocols/Aws_json1_1";
+var LookupDeveloperIdentityCommand = (function (_super) {
+    __extends(LookupDeveloperIdentityCommand, _super);
+    function LookupDeveloperIdentityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    LookupDeveloperIdentityCommand.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 = "CognitoIdentityClient";
+        var commandName = "LookupDeveloperIdentityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: LookupDeveloperIdentityInputFilterSensitiveLog,
+            outputFilterSensitiveLog: LookupDeveloperIdentityResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    LookupDeveloperIdentityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1LookupDeveloperIdentityCommand(input, context);
+    };
+    LookupDeveloperIdentityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1LookupDeveloperIdentityCommand(output, context);
+    };
+    return LookupDeveloperIdentityCommand;
+}($Command));
+export { LookupDeveloperIdentityCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/MergeDeveloperIdentitiesCommand.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 { MergeDeveloperIdentitiesInputFilterSensitiveLog, MergeDeveloperIdentitiesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1MergeDeveloperIdentitiesCommand, serializeAws_json1_1MergeDeveloperIdentitiesCommand, } from "../protocols/Aws_json1_1";
+var MergeDeveloperIdentitiesCommand = (function (_super) {
+    __extends(MergeDeveloperIdentitiesCommand, _super);
+    function MergeDeveloperIdentitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    MergeDeveloperIdentitiesCommand.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 = "CognitoIdentityClient";
+        var commandName = "MergeDeveloperIdentitiesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: MergeDeveloperIdentitiesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: MergeDeveloperIdentitiesResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    MergeDeveloperIdentitiesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1MergeDeveloperIdentitiesCommand(input, context);
+    };
+    MergeDeveloperIdentitiesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1MergeDeveloperIdentitiesCommand(output, context);
+    };
+    return MergeDeveloperIdentitiesCommand;
+}($Command));
+export { MergeDeveloperIdentitiesCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/SetIdentityPoolRolesCommand.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 { SetIdentityPoolRolesInputFilterSensitiveLog } from "../models/models_0";
+import { deserializeAws_json1_1SetIdentityPoolRolesCommand, serializeAws_json1_1SetIdentityPoolRolesCommand, } from "../protocols/Aws_json1_1";
+var SetIdentityPoolRolesCommand = (function (_super) {
+    __extends(SetIdentityPoolRolesCommand, _super);
+    function SetIdentityPoolRolesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetIdentityPoolRolesCommand.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 = "CognitoIdentityClient";
+        var commandName = "SetIdentityPoolRolesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetIdentityPoolRolesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetIdentityPoolRolesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1SetIdentityPoolRolesCommand(input, context);
+    };
+    SetIdentityPoolRolesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1SetIdentityPoolRolesCommand(output, context);
+    };
+    return SetIdentityPoolRolesCommand;
+}($Command));
+export { SetIdentityPoolRolesCommand };

package/node_modules/@aws-sdk/client-cognito-identity/dist-es/commands/SetPrincipalTagAttributeMapCommand.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 { SetPrincipalTagAttributeMapInputFilterSensitiveLog, SetPrincipalTagAttributeMapResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1SetPrincipalTagAttributeMapCommand, serializeAws_json1_1SetPrincipalTagAttributeMapCommand, } from "../protocols/Aws_json1_1";
+var SetPrincipalTagAttributeMapCommand = (function (_super) {
+    __extends(SetPrincipalTagAttributeMapCommand, _super);
+    function SetPrincipalTagAttributeMapCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetPrincipalTagAttributeMapCommand.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 = "CognitoIdentityClient";
+        var commandName = "SetPrincipalTagAttributeMapCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetPrincipalTagAttributeMapInputFilterSensitiveLog,
+            outputFilterSensitiveLog: SetPrincipalTagAttributeMapResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetPrincipalTagAttributeMapCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1SetPrincipalTagAttributeMapCommand(input, context);
+    };
+    SetPrincipalTagAttributeMapCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1SetPrincipalTagAttributeMapCommand(output, context);
+    };
+    return SetPrincipalTagAttributeMapCommand;
+}($Command));
+export { SetPrincipalTagAttributeMapCommand };