@aws-sdk/client-cognito-identity 3.315.0 → 3.319.0

package/dist-cjs/CognitoIdentity.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CognitoIdentity = void 0;
+const smithy_client_1 = require("@aws-sdk/smithy-client");
 const CognitoIdentityClient_1 = require("./CognitoIdentityClient");
 const CreateIdentityPoolCommand_1 = require("./commands/CreateIdentityPoolCommand");
 const DeleteIdentitiesCommand_1 = require("./commands/DeleteIdentitiesCommand");
@@ -25,328 +26,32 @@ const UnlinkDeveloperIdentityCommand_1 = require("./commands/UnlinkDeveloperIden
 const UnlinkIdentityCommand_1 = require("./commands/UnlinkIdentityCommand");
 const UntagResourceCommand_1 = require("./commands/UntagResourceCommand");
 const UpdateIdentityPoolCommand_1 = require("./commands/UpdateIdentityPoolCommand");
+const commands = {
+    CreateIdentityPoolCommand: CreateIdentityPoolCommand_1.CreateIdentityPoolCommand,
+    DeleteIdentitiesCommand: DeleteIdentitiesCommand_1.DeleteIdentitiesCommand,
+    DeleteIdentityPoolCommand: DeleteIdentityPoolCommand_1.DeleteIdentityPoolCommand,
+    DescribeIdentityCommand: DescribeIdentityCommand_1.DescribeIdentityCommand,
+    DescribeIdentityPoolCommand: DescribeIdentityPoolCommand_1.DescribeIdentityPoolCommand,
+    GetCredentialsForIdentityCommand: GetCredentialsForIdentityCommand_1.GetCredentialsForIdentityCommand,
+    GetIdCommand: GetIdCommand_1.GetIdCommand,
+    GetIdentityPoolRolesCommand: GetIdentityPoolRolesCommand_1.GetIdentityPoolRolesCommand,
+    GetOpenIdTokenCommand: GetOpenIdTokenCommand_1.GetOpenIdTokenCommand,
+    GetOpenIdTokenForDeveloperIdentityCommand: GetOpenIdTokenForDeveloperIdentityCommand_1.GetOpenIdTokenForDeveloperIdentityCommand,
+    GetPrincipalTagAttributeMapCommand: GetPrincipalTagAttributeMapCommand_1.GetPrincipalTagAttributeMapCommand,
+    ListIdentitiesCommand: ListIdentitiesCommand_1.ListIdentitiesCommand,
+    ListIdentityPoolsCommand: ListIdentityPoolsCommand_1.ListIdentityPoolsCommand,
+    ListTagsForResourceCommand: ListTagsForResourceCommand_1.ListTagsForResourceCommand,
+    LookupDeveloperIdentityCommand: LookupDeveloperIdentityCommand_1.LookupDeveloperIdentityCommand,
+    MergeDeveloperIdentitiesCommand: MergeDeveloperIdentitiesCommand_1.MergeDeveloperIdentitiesCommand,
+    SetIdentityPoolRolesCommand: SetIdentityPoolRolesCommand_1.SetIdentityPoolRolesCommand,
+    SetPrincipalTagAttributeMapCommand: SetPrincipalTagAttributeMapCommand_1.SetPrincipalTagAttributeMapCommand,
+    TagResourceCommand: TagResourceCommand_1.TagResourceCommand,
+    UnlinkDeveloperIdentityCommand: UnlinkDeveloperIdentityCommand_1.UnlinkDeveloperIdentityCommand,
+    UnlinkIdentityCommand: UnlinkIdentityCommand_1.UnlinkIdentityCommand,
+    UntagResourceCommand: UntagResourceCommand_1.UntagResourceCommand,
+    UpdateIdentityPoolCommand: UpdateIdentityPoolCommand_1.UpdateIdentityPoolCommand,
+};
 class CognitoIdentity extends CognitoIdentityClient_1.CognitoIdentityClient {
-    createIdentityPool(args, optionsOrCb, cb) {
-        const command = new CreateIdentityPoolCommand_1.CreateIdentityPoolCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    deleteIdentities(args, optionsOrCb, cb) {
-        const command = new DeleteIdentitiesCommand_1.DeleteIdentitiesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    deleteIdentityPool(args, optionsOrCb, cb) {
-        const command = new DeleteIdentityPoolCommand_1.DeleteIdentityPoolCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    describeIdentity(args, optionsOrCb, cb) {
-        const command = new DescribeIdentityCommand_1.DescribeIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    describeIdentityPool(args, optionsOrCb, cb) {
-        const command = new DescribeIdentityPoolCommand_1.DescribeIdentityPoolCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getCredentialsForIdentity(args, optionsOrCb, cb) {
-        const command = new GetCredentialsForIdentityCommand_1.GetCredentialsForIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getId(args, optionsOrCb, cb) {
-        const command = new GetIdCommand_1.GetIdCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getIdentityPoolRoles(args, optionsOrCb, cb) {
-        const command = new GetIdentityPoolRolesCommand_1.GetIdentityPoolRolesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getOpenIdToken(args, optionsOrCb, cb) {
-        const command = new GetOpenIdTokenCommand_1.GetOpenIdTokenCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getOpenIdTokenForDeveloperIdentity(args, optionsOrCb, cb) {
-        const command = new GetOpenIdTokenForDeveloperIdentityCommand_1.GetOpenIdTokenForDeveloperIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getPrincipalTagAttributeMap(args, optionsOrCb, cb) {
-        const command = new GetPrincipalTagAttributeMapCommand_1.GetPrincipalTagAttributeMapCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    listIdentities(args, optionsOrCb, cb) {
-        const command = new ListIdentitiesCommand_1.ListIdentitiesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    listIdentityPools(args, optionsOrCb, cb) {
-        const command = new ListIdentityPoolsCommand_1.ListIdentityPoolsCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand_1.ListTagsForResourceCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    lookupDeveloperIdentity(args, optionsOrCb, cb) {
-        const command = new LookupDeveloperIdentityCommand_1.LookupDeveloperIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    mergeDeveloperIdentities(args, optionsOrCb, cb) {
-        const command = new MergeDeveloperIdentitiesCommand_1.MergeDeveloperIdentitiesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    setIdentityPoolRoles(args, optionsOrCb, cb) {
-        const command = new SetIdentityPoolRolesCommand_1.SetIdentityPoolRolesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    setPrincipalTagAttributeMap(args, optionsOrCb, cb) {
-        const command = new SetPrincipalTagAttributeMapCommand_1.SetPrincipalTagAttributeMapCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand_1.TagResourceCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    unlinkDeveloperIdentity(args, optionsOrCb, cb) {
-        const command = new UnlinkDeveloperIdentityCommand_1.UnlinkDeveloperIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    unlinkIdentity(args, optionsOrCb, cb) {
-        const command = new UnlinkIdentityCommand_1.UnlinkIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand_1.UntagResourceCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    updateIdentityPool(args, optionsOrCb, cb) {
-        const command = new UpdateIdentityPoolCommand_1.UpdateIdentityPoolCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
 }
 exports.CognitoIdentity = CognitoIdentity;
+(0, smithy_client_1.createAggregatedClient)(commands, CognitoIdentity);

package/dist-es/CognitoIdentity.js

@@ -1,3 +1,4 @@
+import { createAggregatedClient } from "@aws-sdk/smithy-client";
 import { CognitoIdentityClient } from "./CognitoIdentityClient";
 import { CreateIdentityPoolCommand, } from "./commands/CreateIdentityPoolCommand";
 import { DeleteIdentitiesCommand, } from "./commands/DeleteIdentitiesCommand";
@@ -22,327 +23,31 @@ import { UnlinkDeveloperIdentityCommand, } from "./commands/UnlinkDeveloperIdent
 import { UnlinkIdentityCommand, } from "./commands/UnlinkIdentityCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateIdentityPoolCommand, } from "./commands/UpdateIdentityPoolCommand";
+const commands = {
+    CreateIdentityPoolCommand,
+    DeleteIdentitiesCommand,
+    DeleteIdentityPoolCommand,
+    DescribeIdentityCommand,
+    DescribeIdentityPoolCommand,
+    GetCredentialsForIdentityCommand,
+    GetIdCommand,
+    GetIdentityPoolRolesCommand,
+    GetOpenIdTokenCommand,
+    GetOpenIdTokenForDeveloperIdentityCommand,
+    GetPrincipalTagAttributeMapCommand,
+    ListIdentitiesCommand,
+    ListIdentityPoolsCommand,
+    ListTagsForResourceCommand,
+    LookupDeveloperIdentityCommand,
+    MergeDeveloperIdentitiesCommand,
+    SetIdentityPoolRolesCommand,
+    SetPrincipalTagAttributeMapCommand,
+    TagResourceCommand,
+    UnlinkDeveloperIdentityCommand,
+    UnlinkIdentityCommand,
+    UntagResourceCommand,
+    UpdateIdentityPoolCommand,
+};
 export class CognitoIdentity extends CognitoIdentityClient {
-    createIdentityPool(args, optionsOrCb, cb) {
-        const command = new CreateIdentityPoolCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    deleteIdentities(args, optionsOrCb, cb) {
-        const command = new DeleteIdentitiesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    deleteIdentityPool(args, optionsOrCb, cb) {
-        const command = new DeleteIdentityPoolCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    describeIdentity(args, optionsOrCb, cb) {
-        const command = new DescribeIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    describeIdentityPool(args, optionsOrCb, cb) {
-        const command = new DescribeIdentityPoolCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getCredentialsForIdentity(args, optionsOrCb, cb) {
-        const command = new GetCredentialsForIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getId(args, optionsOrCb, cb) {
-        const command = new GetIdCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getIdentityPoolRoles(args, optionsOrCb, cb) {
-        const command = new GetIdentityPoolRolesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getOpenIdToken(args, optionsOrCb, cb) {
-        const command = new GetOpenIdTokenCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getOpenIdTokenForDeveloperIdentity(args, optionsOrCb, cb) {
-        const command = new GetOpenIdTokenForDeveloperIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    getPrincipalTagAttributeMap(args, optionsOrCb, cb) {
-        const command = new GetPrincipalTagAttributeMapCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    listIdentities(args, optionsOrCb, cb) {
-        const command = new ListIdentitiesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    listIdentityPools(args, optionsOrCb, cb) {
-        const command = new ListIdentityPoolsCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    lookupDeveloperIdentity(args, optionsOrCb, cb) {
-        const command = new LookupDeveloperIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    mergeDeveloperIdentities(args, optionsOrCb, cb) {
-        const command = new MergeDeveloperIdentitiesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    setIdentityPoolRoles(args, optionsOrCb, cb) {
-        const command = new SetIdentityPoolRolesCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    setPrincipalTagAttributeMap(args, optionsOrCb, cb) {
-        const command = new SetPrincipalTagAttributeMapCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    unlinkDeveloperIdentity(args, optionsOrCb, cb) {
-        const command = new UnlinkDeveloperIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    unlinkIdentity(args, optionsOrCb, cb) {
-        const command = new UnlinkIdentityCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
-    updateIdentityPool(args, optionsOrCb, cb) {
-        const command = new UpdateIdentityPoolCommand(args);
-        if (typeof optionsOrCb === "function") {
-            this.send(command, optionsOrCb);
-        }
-        else if (typeof cb === "function") {
-            if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
-            this.send(command, optionsOrCb || {}, cb);
-        }
-        else {
-            return this.send(command, optionsOrCb);
-        }
-    }
 }
+createAggregatedClient(commands, CognitoIdentity);

package/dist-types/CognitoIdentity.d.ts

@@ -23,297 +23,162 @@ import { UnlinkDeveloperIdentityCommandInput, UnlinkDeveloperIdentityCommandOutp
 import { UnlinkIdentityCommandInput, UnlinkIdentityCommandOutput } from "./commands/UnlinkIdentityCommand";
 import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 import { UpdateIdentityPoolCommandInput, UpdateIdentityPoolCommandOutput } from "./commands/UpdateIdentityPoolCommand";
-/**
- * @public
- * <fullname>Amazon Cognito Federated Identities</fullname>
- *          <p>Amazon Cognito Federated Identities is a web service that delivers scoped temporary
- *          credentials to mobile devices and other untrusted environments. It uniquely identifies a
- *          device and supplies the user with a consistent identity over the lifetime of an
- *          application.</p>
- *          <p>Using Amazon Cognito Federated Identities, you can enable authentication with one or
- *          more third-party identity providers (Facebook, Google, or Login with Amazon) or an Amazon
- *          Cognito user pool, and you can also choose to support unauthenticated access from your app.
- *          Cognito delivers a unique identifier for each user and acts as an OpenID token provider
- *          trusted by AWS Security Token Service (STS) to access temporary, limited-privilege AWS
- *          credentials.</p>
- *          <p>For a description of the authentication flow from the Amazon Cognito Developer Guide
- *          see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html">Authentication Flow</a>.</p>
- *          <p>For more information see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html">Amazon Cognito Federated Identities</a>.</p>
- */
-export declare class CognitoIdentity extends CognitoIdentityClient {
+export interface CognitoIdentity {
     /**
-     * @public
-     * <p>Creates a new identity pool. The identity pool is a store of user identity
-     *          information that is specific to your AWS account. The keys for <code>SupportedLoginProviders</code> are as follows:</p>
-     *
-     *          <ul>
-     *             <li>
-     *                <p>Facebook: <code>graph.facebook.com</code>
-     *                </p>
-     *             </li>
-     *             <li>
-     *                <p>Google: <code>accounts.google.com</code>
-     *                </p>
-     *             </li>
-     *             <li>
-     *                <p>Amazon: <code>www.amazon.com</code>
-     *                </p>
-     *             </li>
-     *             <li>
-     *                <p>Twitter: <code>api.twitter.com</code>
-     *                </p>
-     *             </li>
-     *             <li>
-     *                <p>Digits: <code>www.digits.com</code>
-     *                </p>
-     *             </li>
-     *          </ul>
-     *
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link CreateIdentityPoolCommand}
      */
     createIdentityPool(args: CreateIdentityPoolCommandInput, options?: __HttpHandlerOptions): Promise<CreateIdentityPoolCommandOutput>;
     createIdentityPool(args: CreateIdentityPoolCommandInput, cb: (err: any, data?: CreateIdentityPoolCommandOutput) => void): void;
     createIdentityPool(args: CreateIdentityPoolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateIdentityPoolCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes identities from an identity pool. You can specify a list of 1-60 identities
-     *          that you want to delete.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link DeleteIdentitiesCommand}
      */
     deleteIdentities(args: DeleteIdentitiesCommandInput, options?: __HttpHandlerOptions): Promise<DeleteIdentitiesCommandOutput>;
     deleteIdentities(args: DeleteIdentitiesCommandInput, cb: (err: any, data?: DeleteIdentitiesCommandOutput) => void): void;
     deleteIdentities(args: DeleteIdentitiesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteIdentitiesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes an identity pool. Once a pool is deleted, users will not be able to
-     *          authenticate with the pool.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link DeleteIdentityPoolCommand}
      */
     deleteIdentityPool(args: DeleteIdentityPoolCommandInput, options?: __HttpHandlerOptions): Promise<DeleteIdentityPoolCommandOutput>;
     deleteIdentityPool(args: DeleteIdentityPoolCommandInput, cb: (err: any, data?: DeleteIdentityPoolCommandOutput) => void): void;
     deleteIdentityPool(args: DeleteIdentityPoolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteIdentityPoolCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns metadata related to the given identity, including when the identity was
-     *          created and any associated linked logins.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link DescribeIdentityCommand}
      */
     describeIdentity(args: DescribeIdentityCommandInput, options?: __HttpHandlerOptions): Promise<DescribeIdentityCommandOutput>;
     describeIdentity(args: DescribeIdentityCommandInput, cb: (err: any, data?: DescribeIdentityCommandOutput) => void): void;
     describeIdentity(args: DescribeIdentityCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeIdentityCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets details about a particular identity pool, including the pool name, ID
-     *          description, creation date, and current number of users.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link DescribeIdentityPoolCommand}
      */
     describeIdentityPool(args: DescribeIdentityPoolCommandInput, options?: __HttpHandlerOptions): Promise<DescribeIdentityPoolCommandOutput>;
     describeIdentityPool(args: DescribeIdentityPoolCommandInput, cb: (err: any, data?: DescribeIdentityPoolCommandOutput) => void): void;
     describeIdentityPool(args: DescribeIdentityPoolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeIdentityPoolCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns credentials for the provided identity ID. Any provided logins will be
-     *          validated against supported login providers. If the token is for
-     *          cognito-identity.amazonaws.com, it will be passed through to AWS Security Token Service
-     *          with the appropriate role for the token.</p>
-     *          <p>This is a public API. You do not need any credentials to call this API.</p>
+     * @see {@link GetCredentialsForIdentityCommand}
      */
     getCredentialsForIdentity(args: GetCredentialsForIdentityCommandInput, options?: __HttpHandlerOptions): Promise<GetCredentialsForIdentityCommandOutput>;
     getCredentialsForIdentity(args: GetCredentialsForIdentityCommandInput, cb: (err: any, data?: GetCredentialsForIdentityCommandOutput) => void): void;
     getCredentialsForIdentity(args: GetCredentialsForIdentityCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetCredentialsForIdentityCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Generates (or retrieves) a Cognito ID. Supplying multiple logins will create an
-     *          implicit linked account.</p>
-     *          <p>This is a public API. You do not need any credentials to call this API.</p>
+     * @see {@link GetIdCommand}
      */
     getId(args: GetIdCommandInput, options?: __HttpHandlerOptions): Promise<GetIdCommandOutput>;
     getId(args: GetIdCommandInput, cb: (err: any, data?: GetIdCommandOutput) => void): void;
     getId(args: GetIdCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetIdCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets the roles for an identity pool.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link GetIdentityPoolRolesCommand}
      */
     getIdentityPoolRoles(args: GetIdentityPoolRolesCommandInput, options?: __HttpHandlerOptions): Promise<GetIdentityPoolRolesCommandOutput>;
     getIdentityPoolRoles(args: GetIdentityPoolRolesCommandInput, cb: (err: any, data?: GetIdentityPoolRolesCommandOutput) => void): void;
     getIdentityPoolRoles(args: GetIdentityPoolRolesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetIdentityPoolRolesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets an OpenID token, using a known Cognito ID. This known Cognito ID is returned by
-     *             <a>GetId</a>. You can optionally add additional logins for the identity.
-     *          Supplying multiple logins creates an implicit link.</p>
-     *          <p>The OpenID token is valid for 10 minutes.</p>
-     *          <p>This is a public API. You do not need any credentials to call this API.</p>
+     * @see {@link GetOpenIdTokenCommand}
      */
     getOpenIdToken(args: GetOpenIdTokenCommandInput, options?: __HttpHandlerOptions): Promise<GetOpenIdTokenCommandOutput>;
     getOpenIdToken(args: GetOpenIdTokenCommandInput, cb: (err: any, data?: GetOpenIdTokenCommandOutput) => void): void;
     getOpenIdToken(args: GetOpenIdTokenCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetOpenIdTokenCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Registers (or retrieves) a Cognito <code>IdentityId</code> and an OpenID Connect
-     *          token for a user authenticated by your backend authentication process. Supplying multiple
-     *          logins will create an implicit linked account. You can only specify one developer provider
-     *          as part of the <code>Logins</code> map, which is linked to the identity pool. The developer
-     *          provider is the "domain" by which Cognito will refer to your users.</p>
-     *          <p>You can use <code>GetOpenIdTokenForDeveloperIdentity</code> to create a new identity
-     *          and to link new logins (that is, user credentials issued by a public provider or developer
-     *          provider) to an existing identity. When you want to create a new identity, the
-     *             <code>IdentityId</code> should be null. When you want to associate a new login with an
-     *          existing authenticated/unauthenticated identity, you can do so by providing the existing
-     *             <code>IdentityId</code>. This API will create the identity in the specified
-     *             <code>IdentityPoolId</code>.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link GetOpenIdTokenForDeveloperIdentityCommand}
      */
     getOpenIdTokenForDeveloperIdentity(args: GetOpenIdTokenForDeveloperIdentityCommandInput, options?: __HttpHandlerOptions): Promise<GetOpenIdTokenForDeveloperIdentityCommandOutput>;
     getOpenIdTokenForDeveloperIdentity(args: GetOpenIdTokenForDeveloperIdentityCommandInput, cb: (err: any, data?: GetOpenIdTokenForDeveloperIdentityCommandOutput) => void): void;
     getOpenIdTokenForDeveloperIdentity(args: GetOpenIdTokenForDeveloperIdentityCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetOpenIdTokenForDeveloperIdentityCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Use <code>GetPrincipalTagAttributeMap</code> to list all mappings between <code>PrincipalTags</code> and user attributes.</p>
+     * @see {@link GetPrincipalTagAttributeMapCommand}
      */
     getPrincipalTagAttributeMap(args: GetPrincipalTagAttributeMapCommandInput, options?: __HttpHandlerOptions): Promise<GetPrincipalTagAttributeMapCommandOutput>;
     getPrincipalTagAttributeMap(args: GetPrincipalTagAttributeMapCommandInput, cb: (err: any, data?: GetPrincipalTagAttributeMapCommandOutput) => void): void;
     getPrincipalTagAttributeMap(args: GetPrincipalTagAttributeMapCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetPrincipalTagAttributeMapCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the identities in an identity pool.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link ListIdentitiesCommand}
      */
     listIdentities(args: ListIdentitiesCommandInput, options?: __HttpHandlerOptions): Promise<ListIdentitiesCommandOutput>;
     listIdentities(args: ListIdentitiesCommandInput, cb: (err: any, data?: ListIdentitiesCommandOutput) => void): void;
     listIdentities(args: ListIdentitiesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListIdentitiesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists all of the Cognito identity pools registered for your account.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link ListIdentityPoolsCommand}
      */
     listIdentityPools(args: ListIdentityPoolsCommandInput, options?: __HttpHandlerOptions): Promise<ListIdentityPoolsCommandOutput>;
     listIdentityPools(args: ListIdentityPoolsCommandInput, cb: (err: any, data?: ListIdentityPoolsCommandOutput) => void): void;
     listIdentityPools(args: ListIdentityPoolsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListIdentityPoolsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the tags that are assigned to an Amazon Cognito identity pool.</p>
-     *          <p>A tag is a label that you can apply to identity pools to categorize and manage them in
-     *          different ways, such as by purpose, owner, environment, or other criteria.</p>
-     *          <p>You can use this action up to 10 times per second, per account.</p>
+     * @see {@link ListTagsForResourceCommand}
      */
     listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the <code>IdentityID</code> associated with a
-     *             <code>DeveloperUserIdentifier</code> or the list of <code>DeveloperUserIdentifier</code>
-     *          values associated with an <code>IdentityId</code> for an existing identity. Either
-     *             <code>IdentityID</code> or <code>DeveloperUserIdentifier</code> must not be null. If you
-     *          supply only one of these values, the other value will be searched in the database and
-     *          returned as a part of the response. If you supply both,
-     *             <code>DeveloperUserIdentifier</code> will be matched against <code>IdentityID</code>. If
-     *          the values are verified against the database, the response returns both values and is the
-     *          same as the request. Otherwise a <code>ResourceConflictException</code> is
-     *          thrown.</p>
-     *          <p>
-     *             <code>LookupDeveloperIdentity</code> is intended for low-throughput control plane
-     *          operations: for example, to enable customer service to locate an identity ID by username.
-     *          If you are using it for higher-volume operations such as user authentication, your requests
-     *          are likely to be throttled. <a>GetOpenIdTokenForDeveloperIdentity</a> is a
-     *          better option for higher-volume operations for user authentication.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link LookupDeveloperIdentityCommand}
      */
     lookupDeveloperIdentity(args: LookupDeveloperIdentityCommandInput, options?: __HttpHandlerOptions): Promise<LookupDeveloperIdentityCommandOutput>;
     lookupDeveloperIdentity(args: LookupDeveloperIdentityCommandInput, cb: (err: any, data?: LookupDeveloperIdentityCommandOutput) => void): void;
     lookupDeveloperIdentity(args: LookupDeveloperIdentityCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: LookupDeveloperIdentityCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Merges two users having different <code>IdentityId</code>s, existing in the same
-     *          identity pool, and identified by the same developer provider. You can use this action to
-     *          request that discrete users be merged and identified as a single user in the Cognito
-     *          environment. Cognito associates the given source user (<code>SourceUserIdentifier</code>)
-     *          with the <code>IdentityId</code> of the <code>DestinationUserIdentifier</code>. Only
-     *          developer-authenticated users can be merged. If the users to be merged are associated with
-     *          the same public provider, but as two different users, an exception will be
-     *          thrown.</p>
-     *          <p>The number of linked logins is limited to 20. So, the number of linked logins for the
-     *          source user, <code>SourceUserIdentifier</code>, and the destination user,
-     *          <code>DestinationUserIdentifier</code>, together should not be larger than 20.
-     *          Otherwise, an exception will be thrown.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link MergeDeveloperIdentitiesCommand}
      */
     mergeDeveloperIdentities(args: MergeDeveloperIdentitiesCommandInput, options?: __HttpHandlerOptions): Promise<MergeDeveloperIdentitiesCommandOutput>;
     mergeDeveloperIdentities(args: MergeDeveloperIdentitiesCommandInput, cb: (err: any, data?: MergeDeveloperIdentitiesCommandOutput) => void): void;
     mergeDeveloperIdentities(args: MergeDeveloperIdentitiesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: MergeDeveloperIdentitiesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Sets the roles for an identity pool. These roles are used when making calls to <a>GetCredentialsForIdentity</a> action.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link SetIdentityPoolRolesCommand}
      */
     setIdentityPoolRoles(args: SetIdentityPoolRolesCommandInput, options?: __HttpHandlerOptions): Promise<SetIdentityPoolRolesCommandOutput>;
     setIdentityPoolRoles(args: SetIdentityPoolRolesCommandInput, cb: (err: any, data?: SetIdentityPoolRolesCommandOutput) => void): void;
     setIdentityPoolRoles(args: SetIdentityPoolRolesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SetIdentityPoolRolesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>You can use this operation to use default (username and clientID) attribute or custom attribute mappings.</p>
+     * @see {@link SetPrincipalTagAttributeMapCommand}
      */
     setPrincipalTagAttributeMap(args: SetPrincipalTagAttributeMapCommandInput, options?: __HttpHandlerOptions): Promise<SetPrincipalTagAttributeMapCommandOutput>;
     setPrincipalTagAttributeMap(args: SetPrincipalTagAttributeMapCommandInput, cb: (err: any, data?: SetPrincipalTagAttributeMapCommandOutput) => void): void;
     setPrincipalTagAttributeMap(args: SetPrincipalTagAttributeMapCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SetPrincipalTagAttributeMapCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Assigns a set of tags to the specified Amazon Cognito identity pool. A tag is a label
-     *          that you can use to categorize and manage identity pools in different ways, such as by
-     *          purpose, owner, environment, or other criteria.</p>
-     *          <p>Each tag consists of a key and value, both of which you define. A key is a general
-     *          category for more specific values. For example, if you have two versions of an identity
-     *          pool, one for testing and another for production, you might assign an
-     *             <code>Environment</code> tag key to both identity pools. The value of this key might be
-     *             <code>Test</code> for one identity pool and <code>Production</code> for the
-     *          other.</p>
-     *          <p>Tags are useful for cost tracking and access control. You can activate your tags so that
-     *          they appear on the Billing and Cost Management console, where you can track the costs
-     *          associated with your identity pools. In an IAM policy, you can constrain permissions for
-     *          identity pools based on specific tags or tag values.</p>
-     *          <p>You can use this action up to 5 times per second, per account. An identity pool can have
-     *          as many as 50 tags.</p>
+     * @see {@link TagResourceCommand}
      */
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Unlinks a <code>DeveloperUserIdentifier</code> from an existing identity. Unlinked
-     *          developer users will be considered new identities next time they are seen. If, for a given
-     *          Cognito identity, you remove all federated identities as well as the developer user
-     *          identifier, the Cognito identity becomes inaccessible.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link UnlinkDeveloperIdentityCommand}
      */
     unlinkDeveloperIdentity(args: UnlinkDeveloperIdentityCommandInput, options?: __HttpHandlerOptions): Promise<UnlinkDeveloperIdentityCommandOutput>;
     unlinkDeveloperIdentity(args: UnlinkDeveloperIdentityCommandInput, cb: (err: any, data?: UnlinkDeveloperIdentityCommandOutput) => void): void;
     unlinkDeveloperIdentity(args: UnlinkDeveloperIdentityCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UnlinkDeveloperIdentityCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Unlinks a federated identity from an existing account. Unlinked logins will be
-     *          considered new identities next time they are seen. Removing the last linked login will make
-     *          this identity inaccessible.</p>
-     *          <p>This is a public API. You do not need any credentials to call this API.</p>
+     * @see {@link UnlinkIdentityCommand}
      */
     unlinkIdentity(args: UnlinkIdentityCommandInput, options?: __HttpHandlerOptions): Promise<UnlinkIdentityCommandOutput>;
     unlinkIdentity(args: UnlinkIdentityCommandInput, cb: (err: any, data?: UnlinkIdentityCommandOutput) => void): void;
     unlinkIdentity(args: UnlinkIdentityCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UnlinkIdentityCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Removes the specified tags from the specified Amazon Cognito identity pool. You can use
-     *          this action up to 5 times per second, per account</p>
+     * @see {@link UntagResourceCommand}
      */
     untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
     untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates an identity pool.</p>
-     *          <p>You must use AWS Developer credentials to call this API.</p>
+     * @see {@link UpdateIdentityPoolCommand}
      */
     updateIdentityPool(args: UpdateIdentityPoolCommandInput, options?: __HttpHandlerOptions): Promise<UpdateIdentityPoolCommandOutput>;
     updateIdentityPool(args: UpdateIdentityPoolCommandInput, cb: (err: any, data?: UpdateIdentityPoolCommandOutput) => void): void;
     updateIdentityPool(args: UpdateIdentityPoolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateIdentityPoolCommandOutput) => void): void;
 }
+/**
+ * @public
+ * <fullname>Amazon Cognito Federated Identities</fullname>
+ *          <p>Amazon Cognito Federated Identities is a web service that delivers scoped temporary
+ *          credentials to mobile devices and other untrusted environments. It uniquely identifies a
+ *          device and supplies the user with a consistent identity over the lifetime of an
+ *          application.</p>
+ *          <p>Using Amazon Cognito Federated Identities, you can enable authentication with one or
+ *          more third-party identity providers (Facebook, Google, or Login with Amazon) or an Amazon
+ *          Cognito user pool, and you can also choose to support unauthenticated access from your app.
+ *          Cognito delivers a unique identifier for each user and acts as an OpenID token provider
+ *          trusted by AWS Security Token Service (STS) to access temporary, limited-privilege AWS
+ *          credentials.</p>
+ *          <p>For a description of the authentication flow from the Amazon Cognito Developer Guide
+ *          see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html">Authentication Flow</a>.</p>
+ *          <p>For more information see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html">Amazon Cognito Federated Identities</a>.</p>
+ */
+export declare class CognitoIdentity extends CognitoIdentityClient implements CognitoIdentity {
+}

package/dist-types/ts3.4/CognitoIdentity.d.ts

@@ -89,7 +89,7 @@ import {
   UpdateIdentityPoolCommandInput,
   UpdateIdentityPoolCommandOutput,
 } from "./commands/UpdateIdentityPoolCommand";
-export declare class CognitoIdentity extends CognitoIdentityClient {
+export interface CognitoIdentity {
   createIdentityPool(
     args: CreateIdentityPoolCommandInput,
     options?: __HttpHandlerOptions
@@ -396,3 +396,6 @@ export declare class CognitoIdentity extends CognitoIdentityClient {
     cb: (err: any, data?: UpdateIdentityPoolCommandOutput) => void
   ): void;
 }
+export declare class CognitoIdentity
+  extends CognitoIdentityClient
+  implements CognitoIdentity {}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-cognito-identity",
   "description": "AWS SDK for JavaScript Cognito Identity Client for Node.js, Browser and React Native",
-  "version": "3.315.0",
+  "version": "3.319.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -22,9 +22,9 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "3.0.0",
     "@aws-crypto/sha256-js": "3.0.0",
-    "@aws-sdk/client-sts": "3.315.0",
+    "@aws-sdk/client-sts": "3.319.0",
     "@aws-sdk/config-resolver": "3.310.0",
-    "@aws-sdk/credential-provider-node": "3.315.0",
+    "@aws-sdk/credential-provider-node": "3.319.0",
     "@aws-sdk/fetch-http-handler": "3.310.0",
     "@aws-sdk/hash-node": "3.310.0",
     "@aws-sdk/invalid-dependency": "3.310.0",
@@ -37,19 +37,19 @@
     "@aws-sdk/middleware-serde": "3.310.0",
     "@aws-sdk/middleware-signing": "3.310.0",
     "@aws-sdk/middleware-stack": "3.310.0",
-    "@aws-sdk/middleware-user-agent": "3.310.0",
+    "@aws-sdk/middleware-user-agent": "3.319.0",
     "@aws-sdk/node-config-provider": "3.310.0",
     "@aws-sdk/node-http-handler": "3.310.0",
     "@aws-sdk/protocol-http": "3.310.0",
-    "@aws-sdk/smithy-client": "3.315.0",
+    "@aws-sdk/smithy-client": "3.316.0",
     "@aws-sdk/types": "3.310.0",
     "@aws-sdk/url-parser": "3.310.0",
     "@aws-sdk/util-base64": "3.310.0",
     "@aws-sdk/util-body-length-browser": "3.310.0",
     "@aws-sdk/util-body-length-node": "3.310.0",
-    "@aws-sdk/util-defaults-mode-browser": "3.315.0",
-    "@aws-sdk/util-defaults-mode-node": "3.315.0",
-    "@aws-sdk/util-endpoints": "3.310.0",
+    "@aws-sdk/util-defaults-mode-browser": "3.316.0",
+    "@aws-sdk/util-defaults-mode-node": "3.316.0",
+    "@aws-sdk/util-endpoints": "3.319.0",
     "@aws-sdk/util-retry": "3.310.0",
     "@aws-sdk/util-user-agent-browser": "3.310.0",
     "@aws-sdk/util-user-agent-node": "3.310.0",
@@ -57,7 +57,7 @@
     "tslib": "^2.5.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-iam": "3.315.0",
+    "@aws-sdk/client-iam": "3.319.0",
     "@aws-sdk/service-client-documentation-generator": "3.310.0",
     "@tsconfig/node14": "1.0.3",
     "@types/chai": "^4.2.11",