serverless-spy 0.0.3 → 0.0.6

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/CreateIdentityPoolCommand.d.ts

@@ -0,0 +1,61 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { CreateIdentityPoolInput, IdentityPool } from "../models/models_0";
+export interface CreateIdentityPoolCommandInput extends CreateIdentityPoolInput {
+}
+export interface CreateIdentityPoolCommandOutput extends IdentityPool, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, CreateIdentityPoolCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, CreateIdentityPoolCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new CreateIdentityPoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateIdentityPoolCommandInput} for command's `input` shape.
+ * @see {@link CreateIdentityPoolCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class CreateIdentityPoolCommand extends $Command<CreateIdentityPoolCommandInput, CreateIdentityPoolCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: CreateIdentityPoolCommandInput;
+    constructor(input: CreateIdentityPoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIdentityPoolCommandInput, CreateIdentityPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/DeleteIdentitiesCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { DeleteIdentitiesInput, DeleteIdentitiesResponse } from "../models/models_0";
+export interface DeleteIdentitiesCommandInput extends DeleteIdentitiesInput {
+}
+export interface DeleteIdentitiesCommandOutput extends DeleteIdentitiesResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, DeleteIdentitiesCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, DeleteIdentitiesCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new DeleteIdentitiesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteIdentitiesCommandInput} for command's `input` shape.
+ * @see {@link DeleteIdentitiesCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class DeleteIdentitiesCommand extends $Command<DeleteIdentitiesCommandInput, DeleteIdentitiesCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: DeleteIdentitiesCommandInput;
+    constructor(input: DeleteIdentitiesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteIdentitiesCommandInput, DeleteIdentitiesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/DeleteIdentityPoolCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { DeleteIdentityPoolInput } from "../models/models_0";
+export interface DeleteIdentityPoolCommandInput extends DeleteIdentityPoolInput {
+}
+export interface DeleteIdentityPoolCommandOutput extends __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, DeleteIdentityPoolCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, DeleteIdentityPoolCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new DeleteIdentityPoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteIdentityPoolCommandInput} for command's `input` shape.
+ * @see {@link DeleteIdentityPoolCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class DeleteIdentityPoolCommand extends $Command<DeleteIdentityPoolCommandInput, DeleteIdentityPoolCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: DeleteIdentityPoolCommandInput;
+    constructor(input: DeleteIdentityPoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteIdentityPoolCommandInput, DeleteIdentityPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/DescribeIdentityCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { DescribeIdentityInput, IdentityDescription } from "../models/models_0";
+export interface DescribeIdentityCommandInput extends DescribeIdentityInput {
+}
+export interface DescribeIdentityCommandOutput extends IdentityDescription, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, DescribeIdentityCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, DescribeIdentityCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new DescribeIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeIdentityCommandInput} for command's `input` shape.
+ * @see {@link DescribeIdentityCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class DescribeIdentityCommand extends $Command<DescribeIdentityCommandInput, DescribeIdentityCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: DescribeIdentityCommandInput;
+    constructor(input: DescribeIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeIdentityCommandInput, DescribeIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/DescribeIdentityPoolCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { DescribeIdentityPoolInput, IdentityPool } from "../models/models_0";
+export interface DescribeIdentityPoolCommandInput extends DescribeIdentityPoolInput {
+}
+export interface DescribeIdentityPoolCommandOutput extends IdentityPool, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, DescribeIdentityPoolCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, DescribeIdentityPoolCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new DescribeIdentityPoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeIdentityPoolCommandInput} for command's `input` shape.
+ * @see {@link DescribeIdentityPoolCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class DescribeIdentityPoolCommand extends $Command<DescribeIdentityPoolCommandInput, DescribeIdentityPoolCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: DescribeIdentityPoolCommandInput;
+    constructor(input: DescribeIdentityPoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeIdentityPoolCommandInput, DescribeIdentityPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/GetCredentialsForIdentityCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { GetCredentialsForIdentityInput, GetCredentialsForIdentityResponse } from "../models/models_0";
+export interface GetCredentialsForIdentityCommandInput extends GetCredentialsForIdentityInput {
+}
+export interface GetCredentialsForIdentityCommandOutput extends GetCredentialsForIdentityResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, GetCredentialsForIdentityCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, GetCredentialsForIdentityCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new GetCredentialsForIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCredentialsForIdentityCommandInput} for command's `input` shape.
+ * @see {@link GetCredentialsForIdentityCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class GetCredentialsForIdentityCommand extends $Command<GetCredentialsForIdentityCommandInput, GetCredentialsForIdentityCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: GetCredentialsForIdentityCommandInput;
+    constructor(input: GetCredentialsForIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCredentialsForIdentityCommandInput, GetCredentialsForIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/GetIdCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { GetIdInput, GetIdResponse } from "../models/models_0";
+export interface GetIdCommandInput extends GetIdInput {
+}
+export interface GetIdCommandOutput extends GetIdResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, GetIdCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, GetIdCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new GetIdCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetIdCommandInput} for command's `input` shape.
+ * @see {@link GetIdCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class GetIdCommand extends $Command<GetIdCommandInput, GetIdCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: GetIdCommandInput;
+    constructor(input: GetIdCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdCommandInput, GetIdCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/GetIdentityPoolRolesCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { GetIdentityPoolRolesInput, GetIdentityPoolRolesResponse } from "../models/models_0";
+export interface GetIdentityPoolRolesCommandInput extends GetIdentityPoolRolesInput {
+}
+export interface GetIdentityPoolRolesCommandOutput extends GetIdentityPoolRolesResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the roles for an identity pool.</p>
+ *          <p>You must use AWS Developer credentials to call this API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, GetIdentityPoolRolesCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, GetIdentityPoolRolesCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new GetIdentityPoolRolesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetIdentityPoolRolesCommandInput} for command's `input` shape.
+ * @see {@link GetIdentityPoolRolesCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class GetIdentityPoolRolesCommand extends $Command<GetIdentityPoolRolesCommandInput, GetIdentityPoolRolesCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: GetIdentityPoolRolesCommandInput;
+    constructor(input: GetIdentityPoolRolesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdentityPoolRolesCommandInput, GetIdentityPoolRolesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/GetOpenIdTokenCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { GetOpenIdTokenInput, GetOpenIdTokenResponse } from "../models/models_0";
+export interface GetOpenIdTokenCommandInput extends GetOpenIdTokenInput {
+}
+export interface GetOpenIdTokenCommandOutput extends GetOpenIdTokenResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, GetOpenIdTokenCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, GetOpenIdTokenCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new GetOpenIdTokenCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetOpenIdTokenCommandInput} for command's `input` shape.
+ * @see {@link GetOpenIdTokenCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class GetOpenIdTokenCommand extends $Command<GetOpenIdTokenCommandInput, GetOpenIdTokenCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: GetOpenIdTokenCommandInput;
+    constructor(input: GetOpenIdTokenCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetOpenIdTokenCommandInput, GetOpenIdTokenCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/GetOpenIdTokenForDeveloperIdentityCommand.d.ts

@@ -0,0 +1,47 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { GetOpenIdTokenForDeveloperIdentityInput, GetOpenIdTokenForDeveloperIdentityResponse } from "../models/models_0";
+export interface GetOpenIdTokenForDeveloperIdentityCommandInput extends GetOpenIdTokenForDeveloperIdentityInput {
+}
+export interface GetOpenIdTokenForDeveloperIdentityCommandOutput extends GetOpenIdTokenForDeveloperIdentityResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, GetOpenIdTokenForDeveloperIdentityCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, GetOpenIdTokenForDeveloperIdentityCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new GetOpenIdTokenForDeveloperIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetOpenIdTokenForDeveloperIdentityCommandInput} for command's `input` shape.
+ * @see {@link GetOpenIdTokenForDeveloperIdentityCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class GetOpenIdTokenForDeveloperIdentityCommand extends $Command<GetOpenIdTokenForDeveloperIdentityCommandInput, GetOpenIdTokenForDeveloperIdentityCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: GetOpenIdTokenForDeveloperIdentityCommandInput;
+    constructor(input: GetOpenIdTokenForDeveloperIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetOpenIdTokenForDeveloperIdentityCommandInput, GetOpenIdTokenForDeveloperIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/GetPrincipalTagAttributeMapCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { GetPrincipalTagAttributeMapInput, GetPrincipalTagAttributeMapResponse } from "../models/models_0";
+export interface GetPrincipalTagAttributeMapCommandInput extends GetPrincipalTagAttributeMapInput {
+}
+export interface GetPrincipalTagAttributeMapCommandOutput extends GetPrincipalTagAttributeMapResponse, __MetadataBearer {
+}
+/**
+ * <p>Use <code>GetPrincipalTagAttributeMap</code> to list all mappings between <code>PrincipalTags</code> and user attributes.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, GetPrincipalTagAttributeMapCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, GetPrincipalTagAttributeMapCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new GetPrincipalTagAttributeMapCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetPrincipalTagAttributeMapCommandInput} for command's `input` shape.
+ * @see {@link GetPrincipalTagAttributeMapCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class GetPrincipalTagAttributeMapCommand extends $Command<GetPrincipalTagAttributeMapCommandInput, GetPrincipalTagAttributeMapCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: GetPrincipalTagAttributeMapCommandInput;
+    constructor(input: GetPrincipalTagAttributeMapCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPrincipalTagAttributeMapCommandInput, GetPrincipalTagAttributeMapCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/ListIdentitiesCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { ListIdentitiesInput, ListIdentitiesResponse } from "../models/models_0";
+export interface ListIdentitiesCommandInput extends ListIdentitiesInput {
+}
+export interface ListIdentitiesCommandOutput extends ListIdentitiesResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the identities in an identity pool.</p>
+ *          <p>You must use AWS Developer credentials to call this API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, ListIdentitiesCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, ListIdentitiesCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new ListIdentitiesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListIdentitiesCommandInput} for command's `input` shape.
+ * @see {@link ListIdentitiesCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class ListIdentitiesCommand extends $Command<ListIdentitiesCommandInput, ListIdentitiesCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: ListIdentitiesCommandInput;
+    constructor(input: ListIdentitiesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListIdentitiesCommandInput, ListIdentitiesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/ListIdentityPoolsCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { ListIdentityPoolsInput, ListIdentityPoolsResponse } from "../models/models_0";
+export interface ListIdentityPoolsCommandInput extends ListIdentityPoolsInput {
+}
+export interface ListIdentityPoolsCommandOutput extends ListIdentityPoolsResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, ListIdentityPoolsCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, ListIdentityPoolsCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new ListIdentityPoolsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListIdentityPoolsCommandInput} for command's `input` shape.
+ * @see {@link ListIdentityPoolsCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class ListIdentityPoolsCommand extends $Command<ListIdentityPoolsCommandInput, ListIdentityPoolsCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: ListIdentityPoolsCommandInput;
+    constructor(input: ListIdentityPoolsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListIdentityPoolsCommandInput, ListIdentityPoolsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { ListTagsForResourceInput, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceInput {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, ListTagsForResourceCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, ListTagsForResourceCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/node_modules/@aws-sdk/client-cognito-identity/dist-types/commands/LookupDeveloperIdentityCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityClient";
+import { LookupDeveloperIdentityInput, LookupDeveloperIdentityResponse } from "../models/models_0";
+export interface LookupDeveloperIdentityCommandInput extends LookupDeveloperIdentityInput {
+}
+export interface LookupDeveloperIdentityCommandOutput extends LookupDeveloperIdentityResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityClient, LookupDeveloperIdentityCommand } from "@aws-sdk/client-cognito-identity"; // ES Modules import
+ * // const { CognitoIdentityClient, LookupDeveloperIdentityCommand } = require("@aws-sdk/client-cognito-identity"); // CommonJS import
+ * const client = new CognitoIdentityClient(config);
+ * const command = new LookupDeveloperIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link LookupDeveloperIdentityCommandInput} for command's `input` shape.
+ * @see {@link LookupDeveloperIdentityCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityClientResolvedConfig | config} for CognitoIdentityClient's `config` shape.
+ *
+ */
+export declare class LookupDeveloperIdentityCommand extends $Command<LookupDeveloperIdentityCommandInput, LookupDeveloperIdentityCommandOutput, CognitoIdentityClientResolvedConfig> {
+    readonly input: LookupDeveloperIdentityCommandInput;
+    constructor(input: LookupDeveloperIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityClientResolvedConfig, options?: __HttpHandlerOptions): Handler<LookupDeveloperIdentityCommandInput, LookupDeveloperIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}