Documentation

Overview

    Package cognitoidentity provides the API client, operations, and parameter types for Amazon Cognito Identity.

    Amazon Cognito Federated Identities 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. 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. For a description of the authentication flow from the Amazon Cognito Developer Guide see Authentication Flow (https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html). For more information see Amazon Cognito Federated Identities (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html).

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2014-06-30"
    View Source
    const ServiceID = "Cognito Identity"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for Amazon Cognito Identity.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) CreateIdentityPool

                func (c *Client) CreateIdentityPool(ctx context.Context, params *CreateIdentityPoolInput, optFns ...func(*Options)) (*CreateIdentityPoolOutput, error)

                  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 SupportedLoginProviders are as follows:

                  * Facebook: graph.facebook.com

                  * Google: accounts.google.com

                  * Amazon: www.amazon.com

                  * Twitter: api.twitter.com

                  * Digits: www.digits.com

                  You must use AWS Developer credentials to call this API.

                  func (*Client) DeleteIdentities

                  func (c *Client) DeleteIdentities(ctx context.Context, params *DeleteIdentitiesInput, optFns ...func(*Options)) (*DeleteIdentitiesOutput, error)

                    Deletes identities from an identity pool. You can specify a list of 1-60 identities that you want to delete. You must use AWS Developer credentials to call this API.

                    func (*Client) DeleteIdentityPool

                    func (c *Client) DeleteIdentityPool(ctx context.Context, params *DeleteIdentityPoolInput, optFns ...func(*Options)) (*DeleteIdentityPoolOutput, error)

                      Deletes an identity pool. Once a pool is deleted, users will not be able to authenticate with the pool. You must use AWS Developer credentials to call this API.

                      func (*Client) DescribeIdentity

                      func (c *Client) DescribeIdentity(ctx context.Context, params *DescribeIdentityInput, optFns ...func(*Options)) (*DescribeIdentityOutput, error)

                        Returns metadata related to the given identity, including when the identity was created and any associated linked logins. You must use AWS Developer credentials to call this API.

                        func (*Client) DescribeIdentityPool

                        func (c *Client) DescribeIdentityPool(ctx context.Context, params *DescribeIdentityPoolInput, optFns ...func(*Options)) (*DescribeIdentityPoolOutput, error)

                          Gets details about a particular identity pool, including the pool name, ID description, creation date, and current number of users. You must use AWS Developer credentials to call this API.

                          func (*Client) GetCredentialsForIdentity

                          func (c *Client) GetCredentialsForIdentity(ctx context.Context, params *GetCredentialsForIdentityInput, optFns ...func(*Options)) (*GetCredentialsForIdentityOutput, error)

                            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. This is a public API. You do not need any credentials to call this API.

                            func (*Client) GetId

                            func (c *Client) GetId(ctx context.Context, params *GetIdInput, optFns ...func(*Options)) (*GetIdOutput, error)

                              Generates (or retrieves) a Cognito ID. Supplying multiple logins will create an implicit linked account. This is a public API. You do not need any credentials to call this API.

                              func (*Client) GetIdentityPoolRoles

                              func (c *Client) GetIdentityPoolRoles(ctx context.Context, params *GetIdentityPoolRolesInput, optFns ...func(*Options)) (*GetIdentityPoolRolesOutput, error)

                                Gets the roles for an identity pool. You must use AWS Developer credentials to call this API.

                                func (*Client) GetOpenIdToken

                                func (c *Client) GetOpenIdToken(ctx context.Context, params *GetOpenIdTokenInput, optFns ...func(*Options)) (*GetOpenIdTokenOutput, error)

                                  Gets an OpenID token, using a known Cognito ID. This known Cognito ID is returned by GetId. You can optionally add additional logins for the identity. Supplying multiple logins creates an implicit link. The OpenId token is valid for 10 minutes. This is a public API. You do not need any credentials to call this API.

                                  func (*Client) GetOpenIdTokenForDeveloperIdentity

                                  func (c *Client) GetOpenIdTokenForDeveloperIdentity(ctx context.Context, params *GetOpenIdTokenForDeveloperIdentityInput, optFns ...func(*Options)) (*GetOpenIdTokenForDeveloperIdentityOutput, error)

                                    Registers (or retrieves) a Cognito IdentityId 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 Logins map, which is linked to the identity pool. The developer provider is the "domain" by which Cognito will refer to your users. You can use GetOpenIdTokenForDeveloperIdentity 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 IdentityId 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 IdentityId. This API will create the identity in the specified IdentityPoolId. You must use AWS Developer credentials to call this API.

                                    func (*Client) ListIdentities

                                    func (c *Client) ListIdentities(ctx context.Context, params *ListIdentitiesInput, optFns ...func(*Options)) (*ListIdentitiesOutput, error)

                                      Lists the identities in an identity pool. You must use AWS Developer credentials to call this API.

                                      func (*Client) ListIdentityPools

                                      func (c *Client) ListIdentityPools(ctx context.Context, params *ListIdentityPoolsInput, optFns ...func(*Options)) (*ListIdentityPoolsOutput, error)

                                        Lists all of the Cognito identity pools registered for your account. You must use AWS Developer credentials to call this API.

                                        func (*Client) ListTagsForResource

                                        func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                          Lists the tags that are assigned to an Amazon Cognito identity pool. 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. You can use this action up to 10 times per second, per account.

                                          func (*Client) LookupDeveloperIdentity

                                          func (c *Client) LookupDeveloperIdentity(ctx context.Context, params *LookupDeveloperIdentityInput, optFns ...func(*Options)) (*LookupDeveloperIdentityOutput, error)

                                            Retrieves the IdentityID associated with a DeveloperUserIdentifier or the list of DeveloperUserIdentifier values associated with an IdentityId for an existing identity. Either IdentityID or DeveloperUserIdentifier 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, DeveloperUserIdentifier will be matched against IdentityID. If the values are verified against the database, the response returns both values and is the same as the request. Otherwise a ResourceConflictException is thrown. LookupDeveloperIdentity 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. GetOpenIdTokenForDeveloperIdentity is a better option for higher-volume operations for user authentication. You must use AWS Developer credentials to call this API.

                                            func (*Client) MergeDeveloperIdentities

                                            func (c *Client) MergeDeveloperIdentities(ctx context.Context, params *MergeDeveloperIdentitiesInput, optFns ...func(*Options)) (*MergeDeveloperIdentitiesOutput, error)

                                              Merges two users having different IdentityIds, 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 (SourceUserIdentifier) with the IdentityId of the DestinationUserIdentifier. 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. The number of linked logins is limited to 20. So, the number of linked logins for the source user, SourceUserIdentifier, and the destination user, DestinationUserIdentifier, together should not be larger than 20. Otherwise, an exception will be thrown. You must use AWS Developer credentials to call this API.

                                              func (*Client) SetIdentityPoolRoles

                                              func (c *Client) SetIdentityPoolRoles(ctx context.Context, params *SetIdentityPoolRolesInput, optFns ...func(*Options)) (*SetIdentityPoolRolesOutput, error)

                                                Sets the roles for an identity pool. These roles are used when making calls to GetCredentialsForIdentity action. You must use AWS Developer credentials to call this API.

                                                func (*Client) TagResource

                                                func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                  Assigns a set of tags to an 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. 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 Environment tag key to both identity pools. The value of this key might be Test for one identity pool and Production for the other. 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. You can use this action up to 5 times per second, per account. An identity pool can have as many as 50 tags.

                                                  func (*Client) UnlinkDeveloperIdentity

                                                  func (c *Client) UnlinkDeveloperIdentity(ctx context.Context, params *UnlinkDeveloperIdentityInput, optFns ...func(*Options)) (*UnlinkDeveloperIdentityOutput, error)

                                                    Unlinks a DeveloperUserIdentifier 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. You must use AWS Developer credentials to call this API.

                                                    func (*Client) UnlinkIdentity

                                                    func (c *Client) UnlinkIdentity(ctx context.Context, params *UnlinkIdentityInput, optFns ...func(*Options)) (*UnlinkIdentityOutput, error)

                                                      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. This is a public API. You do not need any credentials to call this API.

                                                      func (*Client) UntagResource

                                                      func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                        Removes the specified tags from an Amazon Cognito identity pool. You can use this action up to 5 times per second, per account

                                                        func (*Client) UpdateIdentityPool

                                                        func (c *Client) UpdateIdentityPool(ctx context.Context, params *UpdateIdentityPoolInput, optFns ...func(*Options)) (*UpdateIdentityPoolOutput, error)

                                                          Updates an identity pool. You must use AWS Developer credentials to call this API.

                                                          type CreateIdentityPoolInput

                                                          type CreateIdentityPoolInput struct {
                                                          
                                                          	// TRUE if the identity pool supports unauthenticated logins.
                                                          	//
                                                          	// This member is required.
                                                          	AllowUnauthenticatedIdentities bool
                                                          
                                                          	// A string that you provide.
                                                          	//
                                                          	// This member is required.
                                                          	IdentityPoolName *string
                                                          
                                                          	// Enables or disables the Basic (Classic) authentication flow. For more
                                                          	// information, see Identity Pools (Federated Identities) Authentication Flow
                                                          	// (https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html)
                                                          	// in the Amazon Cognito Developer Guide.
                                                          	AllowClassicFlow *bool
                                                          
                                                          	// An array of Amazon Cognito user pools and their client IDs.
                                                          	CognitoIdentityProviders []types.CognitoIdentityProvider
                                                          
                                                          	// The "domain" by which Cognito will refer to your users. This name acts as a
                                                          	// placeholder that allows your backend and the Cognito service to communicate
                                                          	// about the developer provider. For the DeveloperProviderName, you can use letters
                                                          	// as well as period (.), underscore (_), and dash (-). Once you have set a
                                                          	// developer provider name, you cannot change it. Please take care in setting this
                                                          	// parameter.
                                                          	DeveloperProviderName *string
                                                          
                                                          	// Tags to assign to the identity pool. 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.
                                                          	IdentityPoolTags map[string]string
                                                          
                                                          	// A list of OpendID Connect provider ARNs.
                                                          	OpenIdConnectProviderARNs []string
                                                          
                                                          	// An array of Amazon Resource Names (ARNs) of the SAML provider for your identity
                                                          	// pool.
                                                          	SamlProviderARNs []string
                                                          
                                                          	// Optional key:value pairs mapping provider names to provider app IDs.
                                                          	SupportedLoginProviders map[string]string
                                                          }

                                                            Input to the CreateIdentityPool action.

                                                            type CreateIdentityPoolOutput

                                                            type CreateIdentityPoolOutput struct {
                                                            
                                                            	// TRUE if the identity pool supports unauthenticated logins.
                                                            	//
                                                            	// This member is required.
                                                            	AllowUnauthenticatedIdentities bool
                                                            
                                                            	// An identity pool ID in the format REGION:GUID.
                                                            	//
                                                            	// This member is required.
                                                            	IdentityPoolId *string
                                                            
                                                            	// A string that you provide.
                                                            	//
                                                            	// This member is required.
                                                            	IdentityPoolName *string
                                                            
                                                            	// Enables or disables the Basic (Classic) authentication flow. For more
                                                            	// information, see Identity Pools (Federated Identities) Authentication Flow
                                                            	// (https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html)
                                                            	// in the Amazon Cognito Developer Guide.
                                                            	AllowClassicFlow *bool
                                                            
                                                            	// A list representing an Amazon Cognito user pool and its client ID.
                                                            	CognitoIdentityProviders []types.CognitoIdentityProvider
                                                            
                                                            	// The "domain" by which Cognito will refer to your users.
                                                            	DeveloperProviderName *string
                                                            
                                                            	// The tags that are assigned to the identity pool. 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.
                                                            	IdentityPoolTags map[string]string
                                                            
                                                            	// A list of OpendID Connect provider ARNs.
                                                            	OpenIdConnectProviderARNs []string
                                                            
                                                            	// An array of Amazon Resource Names (ARNs) of the SAML provider for your identity
                                                            	// pool.
                                                            	SamlProviderARNs []string
                                                            
                                                            	// Optional key:value pairs mapping provider names to provider app IDs.
                                                            	SupportedLoginProviders map[string]string
                                                            
                                                            	// Metadata pertaining to the operation's result.
                                                            	ResultMetadata middleware.Metadata
                                                            }

                                                              An object representing an Amazon Cognito identity pool.

                                                              type DeleteIdentitiesInput

                                                              type DeleteIdentitiesInput struct {
                                                              
                                                              	// A list of 1-60 identities that you want to delete.
                                                              	//
                                                              	// This member is required.
                                                              	IdentityIdsToDelete []string
                                                              }

                                                                Input to the DeleteIdentities action.

                                                                type DeleteIdentitiesOutput

                                                                type DeleteIdentitiesOutput struct {
                                                                
                                                                	// An array of UnprocessedIdentityId objects, each of which contains an ErrorCode
                                                                	// and IdentityId.
                                                                	UnprocessedIdentityIds []types.UnprocessedIdentityId
                                                                
                                                                	// Metadata pertaining to the operation's result.
                                                                	ResultMetadata middleware.Metadata
                                                                }

                                                                  Returned in response to a successful DeleteIdentities operation.

                                                                  type DeleteIdentityPoolInput

                                                                  type DeleteIdentityPoolInput struct {
                                                                  
                                                                  	// An identity pool ID in the format REGION:GUID.
                                                                  	//
                                                                  	// This member is required.
                                                                  	IdentityPoolId *string
                                                                  }

                                                                    Input to the DeleteIdentityPool action.

                                                                    type DeleteIdentityPoolOutput

                                                                    type DeleteIdentityPoolOutput struct {
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DescribeIdentityInput

                                                                    type DescribeIdentityInput struct {
                                                                    
                                                                    	// A unique identifier in the format REGION:GUID.
                                                                    	//
                                                                    	// This member is required.
                                                                    	IdentityId *string
                                                                    }

                                                                      Input to the DescribeIdentity action.

                                                                      type DescribeIdentityOutput

                                                                      type DescribeIdentityOutput struct {
                                                                      
                                                                      	// Date on which the identity was created.
                                                                      	CreationDate *time.Time
                                                                      
                                                                      	// A unique identifier in the format REGION:GUID.
                                                                      	IdentityId *string
                                                                      
                                                                      	// Date on which the identity was last modified.
                                                                      	LastModifiedDate *time.Time
                                                                      
                                                                      	// The provider names.
                                                                      	Logins []string
                                                                      
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                        A description of the identity.

                                                                        type DescribeIdentityPoolInput

                                                                        type DescribeIdentityPoolInput struct {
                                                                        
                                                                        	// An identity pool ID in the format REGION:GUID.
                                                                        	//
                                                                        	// This member is required.
                                                                        	IdentityPoolId *string
                                                                        }

                                                                          Input to the DescribeIdentityPool action.

                                                                          type DescribeIdentityPoolOutput

                                                                          type DescribeIdentityPoolOutput struct {
                                                                          
                                                                          	// TRUE if the identity pool supports unauthenticated logins.
                                                                          	//
                                                                          	// This member is required.
                                                                          	AllowUnauthenticatedIdentities bool
                                                                          
                                                                          	// An identity pool ID in the format REGION:GUID.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IdentityPoolId *string
                                                                          
                                                                          	// A string that you provide.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IdentityPoolName *string
                                                                          
                                                                          	// Enables or disables the Basic (Classic) authentication flow. For more
                                                                          	// information, see Identity Pools (Federated Identities) Authentication Flow
                                                                          	// (https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html)
                                                                          	// in the Amazon Cognito Developer Guide.
                                                                          	AllowClassicFlow *bool
                                                                          
                                                                          	// A list representing an Amazon Cognito user pool and its client ID.
                                                                          	CognitoIdentityProviders []types.CognitoIdentityProvider
                                                                          
                                                                          	// The "domain" by which Cognito will refer to your users.
                                                                          	DeveloperProviderName *string
                                                                          
                                                                          	// The tags that are assigned to the identity pool. 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.
                                                                          	IdentityPoolTags map[string]string
                                                                          
                                                                          	// A list of OpendID Connect provider ARNs.
                                                                          	OpenIdConnectProviderARNs []string
                                                                          
                                                                          	// An array of Amazon Resource Names (ARNs) of the SAML provider for your identity
                                                                          	// pool.
                                                                          	SamlProviderARNs []string
                                                                          
                                                                          	// Optional key:value pairs mapping provider names to provider app IDs.
                                                                          	SupportedLoginProviders map[string]string
                                                                          
                                                                          	// Metadata pertaining to the operation's result.
                                                                          	ResultMetadata middleware.Metadata
                                                                          }

                                                                            An object representing an Amazon Cognito identity pool.

                                                                            type EndpointResolver

                                                                            type EndpointResolver interface {
                                                                            	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                            }

                                                                              EndpointResolver interface for resolving service endpoints.

                                                                              func EndpointResolverFromURL

                                                                              func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                type EndpointResolverFunc

                                                                                type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                                  EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                  func (EndpointResolverFunc) ResolveEndpoint

                                                                                  func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                  type EndpointResolverOptions

                                                                                  type EndpointResolverOptions = internalendpoints.Options

                                                                                    EndpointResolverOptions is the service endpoint resolver options

                                                                                    type GetCredentialsForIdentityInput

                                                                                    type GetCredentialsForIdentityInput struct {
                                                                                    
                                                                                    	// A unique identifier in the format REGION:GUID.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	IdentityId *string
                                                                                    
                                                                                    	// The Amazon Resource Name (ARN) of the role to be assumed when multiple roles
                                                                                    	// were received in the token from the identity provider. For example, a SAML-based
                                                                                    	// identity provider. This parameter is optional for identity providers that do not
                                                                                    	// support role customization.
                                                                                    	CustomRoleArn *string
                                                                                    
                                                                                    	// A set of optional name-value pairs that map provider names to provider tokens.
                                                                                    	// The name-value pair will follow the syntax "provider_name":
                                                                                    	// "provider_user_identifier". Logins should not be specified when trying to get
                                                                                    	// credentials for an unauthenticated identity. The Logins parameter is required
                                                                                    	// when using identities associated with external identity providers such as
                                                                                    	// FaceBook. For examples of Logins maps, see the code examples in the External
                                                                                    	// Identity Providers
                                                                                    	// (http://docs.aws.amazon.com/cognito/latest/developerguide/external-identity-providers.html)
                                                                                    	// section of the Amazon Cognito Developer Guide.
                                                                                    	Logins map[string]string
                                                                                    }

                                                                                      Input to the GetCredentialsForIdentity action.

                                                                                      type GetCredentialsForIdentityOutput

                                                                                      type GetCredentialsForIdentityOutput struct {
                                                                                      
                                                                                      	// Credentials for the provided identity ID.
                                                                                      	Credentials *types.Credentials
                                                                                      
                                                                                      	// A unique identifier in the format REGION:GUID.
                                                                                      	IdentityId *string
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                        Returned in response to a successful GetCredentialsForIdentity operation.

                                                                                        type GetIdInput

                                                                                        type GetIdInput struct {
                                                                                        
                                                                                        	// An identity pool ID in the format REGION:GUID.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	IdentityPoolId *string
                                                                                        
                                                                                        	// A standard AWS account ID (9+ digits).
                                                                                        	AccountId *string
                                                                                        
                                                                                        	// A set of optional name-value pairs that map provider names to provider tokens.
                                                                                        	// The available provider names for Logins are as follows:
                                                                                        	//
                                                                                        	// * Facebook:
                                                                                        	// graph.facebook.com
                                                                                        	//
                                                                                        	// * Amazon Cognito user pool: cognito-idp..amazonaws.com/, for
                                                                                        	// example, cognito-idp.us-east-1.amazonaws.com/us-east-1_123456789.
                                                                                        	//
                                                                                        	// * Google:
                                                                                        	// accounts.google.com
                                                                                        	//
                                                                                        	// * Amazon: www.amazon.com
                                                                                        	//
                                                                                        	// * Twitter: api.twitter.com
                                                                                        	//
                                                                                        	// *
                                                                                        	// Digits: www.digits.com
                                                                                        	Logins map[string]string
                                                                                        }

                                                                                          Input to the GetId action.

                                                                                          type GetIdOutput

                                                                                          type GetIdOutput struct {
                                                                                          
                                                                                          	// A unique identifier in the format REGION:GUID.
                                                                                          	IdentityId *string
                                                                                          
                                                                                          	// Metadata pertaining to the operation's result.
                                                                                          	ResultMetadata middleware.Metadata
                                                                                          }

                                                                                            Returned in response to a GetId request.

                                                                                            type GetIdentityPoolRolesInput

                                                                                            type GetIdentityPoolRolesInput struct {
                                                                                            
                                                                                            	// An identity pool ID in the format REGION:GUID.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	IdentityPoolId *string
                                                                                            }

                                                                                              Input to the GetIdentityPoolRoles action.

                                                                                              type GetIdentityPoolRolesOutput

                                                                                              type GetIdentityPoolRolesOutput struct {
                                                                                              
                                                                                              	// An identity pool ID in the format REGION:GUID.
                                                                                              	IdentityPoolId *string
                                                                                              
                                                                                              	// How users for a specific identity provider are to mapped to roles. This is a
                                                                                              	// String-to-RoleMapping object map. The string identifies the identity provider,
                                                                                              	// for example, "graph.facebook.com" or
                                                                                              	// "cognito-idp.us-east-1.amazonaws.com/us-east-1_abcdefghi:app_client_id".
                                                                                              	RoleMappings map[string]types.RoleMapping
                                                                                              
                                                                                              	// The map of roles associated with this pool. Currently only authenticated and
                                                                                              	// unauthenticated roles are supported.
                                                                                              	Roles map[string]string
                                                                                              
                                                                                              	// Metadata pertaining to the operation's result.
                                                                                              	ResultMetadata middleware.Metadata
                                                                                              }

                                                                                                Returned in response to a successful GetIdentityPoolRoles operation.

                                                                                                type GetOpenIdTokenForDeveloperIdentityInput

                                                                                                type GetOpenIdTokenForDeveloperIdentityInput struct {
                                                                                                
                                                                                                	// An identity pool ID in the format REGION:GUID.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	IdentityPoolId *string
                                                                                                
                                                                                                	// A set of optional name-value pairs that map provider names to provider tokens.
                                                                                                	// Each name-value pair represents a user from a public provider or developer
                                                                                                	// provider. If the user is from a developer provider, the name-value pair will
                                                                                                	// follow the syntax "developer_provider_name": "developer_user_identifier". The
                                                                                                	// developer provider is the "domain" by which Cognito will refer to your users;
                                                                                                	// you provided this domain while creating/updating the identity pool. The
                                                                                                	// developer user identifier is an identifier from your backend that uniquely
                                                                                                	// identifies a user. When you create an identity pool, you can specify the
                                                                                                	// supported logins.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Logins map[string]string
                                                                                                
                                                                                                	// A unique identifier in the format REGION:GUID.
                                                                                                	IdentityId *string
                                                                                                
                                                                                                	// The expiration time of the token, in seconds. You can specify a custom
                                                                                                	// expiration time for the token so that you can cache it. If you don't provide an
                                                                                                	// expiration time, the token is valid for 15 minutes. You can exchange the token
                                                                                                	// with Amazon STS for temporary AWS credentials, which are valid for a maximum of
                                                                                                	// one hour. The maximum token duration you can set is 24 hours. You should take
                                                                                                	// care in setting the expiration time for a token, as there are significant
                                                                                                	// security implications: an attacker could use a leaked token to access your AWS
                                                                                                	// resources for the token's duration. Please provide for a small grace period,
                                                                                                	// usually no more than 5 minutes, to account for clock skew.
                                                                                                	TokenDuration *int64
                                                                                                }

                                                                                                  Input to the GetOpenIdTokenForDeveloperIdentity action.

                                                                                                  type GetOpenIdTokenForDeveloperIdentityOutput

                                                                                                  type GetOpenIdTokenForDeveloperIdentityOutput struct {
                                                                                                  
                                                                                                  	// A unique identifier in the format REGION:GUID.
                                                                                                  	IdentityId *string
                                                                                                  
                                                                                                  	// An OpenID token.
                                                                                                  	Token *string
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                    Returned in response to a successful GetOpenIdTokenForDeveloperIdentity request.

                                                                                                    type GetOpenIdTokenInput

                                                                                                    type GetOpenIdTokenInput struct {
                                                                                                    
                                                                                                    	// A unique identifier in the format REGION:GUID.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	IdentityId *string
                                                                                                    
                                                                                                    	// A set of optional name-value pairs that map provider names to provider tokens.
                                                                                                    	// When using graph.facebook.com and www.amazon.com, supply the access_token
                                                                                                    	// returned from the provider's authflow. For accounts.google.com, an Amazon
                                                                                                    	// Cognito user pool provider, or any other OpenId Connect provider, always include
                                                                                                    	// the id_token.
                                                                                                    	Logins map[string]string
                                                                                                    }

                                                                                                      Input to the GetOpenIdToken action.

                                                                                                      type GetOpenIdTokenOutput

                                                                                                      type GetOpenIdTokenOutput struct {
                                                                                                      
                                                                                                      	// A unique identifier in the format REGION:GUID. Note that the IdentityId returned
                                                                                                      	// may not match the one passed on input.
                                                                                                      	IdentityId *string
                                                                                                      
                                                                                                      	// An OpenID token, valid for 10 minutes.
                                                                                                      	Token *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                        Returned in response to a successful GetOpenIdToken request.

                                                                                                        type HTTPClient

                                                                                                        type HTTPClient interface {
                                                                                                        	Do(*http.Request) (*http.Response, error)
                                                                                                        }

                                                                                                        type HTTPSignerV4

                                                                                                        type HTTPSignerV4 interface {
                                                                                                        	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                                        }

                                                                                                        type ListIdentitiesInput

                                                                                                        type ListIdentitiesInput struct {
                                                                                                        
                                                                                                        	// An identity pool ID in the format REGION:GUID.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	IdentityPoolId *string
                                                                                                        
                                                                                                        	// The maximum number of identities to return.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	MaxResults int32
                                                                                                        
                                                                                                        	// An optional boolean parameter that allows you to hide disabled identities. If
                                                                                                        	// omitted, the ListIdentities API will include disabled identities in the
                                                                                                        	// response.
                                                                                                        	HideDisabled bool
                                                                                                        
                                                                                                        	// A pagination token.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                          Input to the ListIdentities action.

                                                                                                          type ListIdentitiesOutput

                                                                                                          type ListIdentitiesOutput struct {
                                                                                                          
                                                                                                          	// An object containing a set of identities and associated mappings.
                                                                                                          	Identities []types.IdentityDescription
                                                                                                          
                                                                                                          	// An identity pool ID in the format REGION:GUID.
                                                                                                          	IdentityPoolId *string
                                                                                                          
                                                                                                          	// A pagination token.
                                                                                                          	NextToken *string
                                                                                                          
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                            The response to a ListIdentities request.

                                                                                                            type ListIdentityPoolsAPIClient

                                                                                                            type ListIdentityPoolsAPIClient interface {
                                                                                                            	ListIdentityPools(context.Context, *ListIdentityPoolsInput, ...func(*Options)) (*ListIdentityPoolsOutput, error)
                                                                                                            }

                                                                                                              ListIdentityPoolsAPIClient is a client that implements the ListIdentityPools operation.

                                                                                                              type ListIdentityPoolsInput

                                                                                                              type ListIdentityPoolsInput struct {
                                                                                                              
                                                                                                              	// The maximum number of identities to return.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	MaxResults int32
                                                                                                              
                                                                                                              	// A pagination token.
                                                                                                              	NextToken *string
                                                                                                              }

                                                                                                                Input to the ListIdentityPools action.

                                                                                                                type ListIdentityPoolsOutput

                                                                                                                type ListIdentityPoolsOutput struct {
                                                                                                                
                                                                                                                	// The identity pools returned by the ListIdentityPools action.
                                                                                                                	IdentityPools []types.IdentityPoolShortDescription
                                                                                                                
                                                                                                                	// A pagination token.
                                                                                                                	NextToken *string
                                                                                                                
                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                }

                                                                                                                  The result of a successful ListIdentityPools action.

                                                                                                                  type ListIdentityPoolsPaginator

                                                                                                                  type ListIdentityPoolsPaginator struct {
                                                                                                                  	// contains filtered or unexported fields
                                                                                                                  }

                                                                                                                    ListIdentityPoolsPaginator is a paginator for ListIdentityPools

                                                                                                                    func NewListIdentityPoolsPaginator

                                                                                                                    func NewListIdentityPoolsPaginator(client ListIdentityPoolsAPIClient, params *ListIdentityPoolsInput, optFns ...func(*ListIdentityPoolsPaginatorOptions)) *ListIdentityPoolsPaginator

                                                                                                                      NewListIdentityPoolsPaginator returns a new ListIdentityPoolsPaginator

                                                                                                                      func (*ListIdentityPoolsPaginator) HasMorePages

                                                                                                                      func (p *ListIdentityPoolsPaginator) HasMorePages() bool

                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                        func (*ListIdentityPoolsPaginator) NextPage

                                                                                                                        func (p *ListIdentityPoolsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListIdentityPoolsOutput, error)

                                                                                                                          NextPage retrieves the next ListIdentityPools page.

                                                                                                                          type ListIdentityPoolsPaginatorOptions

                                                                                                                          type ListIdentityPoolsPaginatorOptions struct {
                                                                                                                          	// The maximum number of identities to return.
                                                                                                                          	Limit int32
                                                                                                                          
                                                                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                          	// that matches the most recent token provided to the service.
                                                                                                                          	StopOnDuplicateToken bool
                                                                                                                          }

                                                                                                                            ListIdentityPoolsPaginatorOptions is the paginator options for ListIdentityPools

                                                                                                                            type ListTagsForResourceInput

                                                                                                                            type ListTagsForResourceInput struct {
                                                                                                                            
                                                                                                                            	// The Amazon Resource Name (ARN) of the identity pool that the tags are assigned
                                                                                                                            	// to.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	ResourceArn *string
                                                                                                                            }

                                                                                                                            type ListTagsForResourceOutput

                                                                                                                            type ListTagsForResourceOutput struct {
                                                                                                                            
                                                                                                                            	// The tags that are assigned to the identity pool.
                                                                                                                            	Tags map[string]string
                                                                                                                            
                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                            }

                                                                                                                            type LookupDeveloperIdentityInput

                                                                                                                            type LookupDeveloperIdentityInput struct {
                                                                                                                            
                                                                                                                            	// An identity pool ID in the format REGION:GUID.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	IdentityPoolId *string
                                                                                                                            
                                                                                                                            	// A unique ID used by your backend authentication process to identify a user.
                                                                                                                            	// Typically, a developer identity provider would issue many developer user
                                                                                                                            	// identifiers, in keeping with the number of users.
                                                                                                                            	DeveloperUserIdentifier *string
                                                                                                                            
                                                                                                                            	// A unique identifier in the format REGION:GUID.
                                                                                                                            	IdentityId *string
                                                                                                                            
                                                                                                                            	// The maximum number of identities to return.
                                                                                                                            	MaxResults int32
                                                                                                                            
                                                                                                                            	// A pagination token. The first call you make will have NextToken set to null.
                                                                                                                            	// After that the service will return NextToken values as needed. For example,
                                                                                                                            	// let's say you make a request with MaxResults set to 10, and there are 20 matches
                                                                                                                            	// in the database. The service will return a pagination token as a part of the
                                                                                                                            	// response. This token can be used to call the API again and get results starting
                                                                                                                            	// from the 11th match.
                                                                                                                            	NextToken *string
                                                                                                                            }

                                                                                                                              Input to the LookupDeveloperIdentityInput action.

                                                                                                                              type LookupDeveloperIdentityOutput

                                                                                                                              type LookupDeveloperIdentityOutput struct {
                                                                                                                              
                                                                                                                              	// This is the list of developer user identifiers associated with an identity ID.
                                                                                                                              	// Cognito supports the association of multiple developer user identifiers with an
                                                                                                                              	// identity ID.
                                                                                                                              	DeveloperUserIdentifierList []string
                                                                                                                              
                                                                                                                              	// A unique identifier in the format REGION:GUID.
                                                                                                                              	IdentityId *string
                                                                                                                              
                                                                                                                              	// A pagination token. The first call you make will have NextToken set to null.
                                                                                                                              	// After that the service will return NextToken values as needed. For example,
                                                                                                                              	// let's say you make a request with MaxResults set to 10, and there are 20 matches
                                                                                                                              	// in the database. The service will return a pagination token as a part of the
                                                                                                                              	// response. This token can be used to call the API again and get results starting
                                                                                                                              	// from the 11th match.
                                                                                                                              	NextToken *string
                                                                                                                              
                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                              }

                                                                                                                                Returned in response to a successful LookupDeveloperIdentity action.

                                                                                                                                type MergeDeveloperIdentitiesInput

                                                                                                                                type MergeDeveloperIdentitiesInput struct {
                                                                                                                                
                                                                                                                                	// User identifier for the destination user. The value should be a
                                                                                                                                	// DeveloperUserIdentifier.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	DestinationUserIdentifier *string
                                                                                                                                
                                                                                                                                	// The "domain" by which Cognito will refer to your users. This is a (pseudo)
                                                                                                                                	// domain name that you provide while creating an identity pool. This name acts as
                                                                                                                                	// a placeholder that allows your backend and the Cognito service to communicate
                                                                                                                                	// about the developer provider. For the DeveloperProviderName, you can use letters
                                                                                                                                	// as well as period (.), underscore (_), and dash (-).
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	DeveloperProviderName *string
                                                                                                                                
                                                                                                                                	// An identity pool ID in the format REGION:GUID.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	IdentityPoolId *string
                                                                                                                                
                                                                                                                                	// User identifier for the source user. The value should be a
                                                                                                                                	// DeveloperUserIdentifier.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	SourceUserIdentifier *string
                                                                                                                                }

                                                                                                                                  Input to the MergeDeveloperIdentities action.

                                                                                                                                  type MergeDeveloperIdentitiesOutput

                                                                                                                                  type MergeDeveloperIdentitiesOutput struct {
                                                                                                                                  
                                                                                                                                  	// A unique identifier in the format REGION:GUID.
                                                                                                                                  	IdentityId *string
                                                                                                                                  
                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                  }

                                                                                                                                    Returned in response to a successful MergeDeveloperIdentities action.

                                                                                                                                    type Options

                                                                                                                                    type Options struct {
                                                                                                                                    	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                    	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                    	// modify this list for per operation behavior.
                                                                                                                                    	APIOptions []func(*middleware.Stack) error
                                                                                                                                    
                                                                                                                                    	// Configures the events that will be sent to the configured logger.
                                                                                                                                    	ClientLogMode aws.ClientLogMode
                                                                                                                                    
                                                                                                                                    	// The credentials object to use when signing requests.
                                                                                                                                    	Credentials aws.CredentialsProvider
                                                                                                                                    
                                                                                                                                    	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                    	EndpointOptions EndpointResolverOptions
                                                                                                                                    
                                                                                                                                    	// The service endpoint resolver.
                                                                                                                                    	EndpointResolver EndpointResolver
                                                                                                                                    
                                                                                                                                    	// Signature Version 4 (SigV4) Signer
                                                                                                                                    	HTTPSignerV4 HTTPSignerV4
                                                                                                                                    
                                                                                                                                    	// The logger writer interface to write logging messages to.
                                                                                                                                    	Logger logging.Logger
                                                                                                                                    
                                                                                                                                    	// The region to send requests to. (Required)
                                                                                                                                    	Region string
                                                                                                                                    
                                                                                                                                    	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                    	// failures. When nil the API client will use a default retryer.
                                                                                                                                    	Retryer aws.Retryer
                                                                                                                                    
                                                                                                                                    	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                    	// implementation if nil.
                                                                                                                                    	HTTPClient HTTPClient
                                                                                                                                    }

                                                                                                                                    func (Options) Copy

                                                                                                                                    func (o Options) Copy() Options

                                                                                                                                      Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                      type ResolveEndpoint

                                                                                                                                      type ResolveEndpoint struct {
                                                                                                                                      	Resolver EndpointResolver
                                                                                                                                      	Options  EndpointResolverOptions
                                                                                                                                      }

                                                                                                                                      func (*ResolveEndpoint) HandleSerialize

                                                                                                                                      func (*ResolveEndpoint) ID

                                                                                                                                      func (*ResolveEndpoint) ID() string

                                                                                                                                      type SetIdentityPoolRolesInput

                                                                                                                                      type SetIdentityPoolRolesInput struct {
                                                                                                                                      
                                                                                                                                      	// An identity pool ID in the format REGION:GUID.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	IdentityPoolId *string
                                                                                                                                      
                                                                                                                                      	// The map of roles associated with this pool. For a given role, the key will be
                                                                                                                                      	// either "authenticated" or "unauthenticated" and the value will be the Role ARN.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Roles map[string]string
                                                                                                                                      
                                                                                                                                      	// How users for a specific identity provider are to mapped to roles. This is a
                                                                                                                                      	// string to RoleMapping object map. The string identifies the identity provider,
                                                                                                                                      	// for example, "graph.facebook.com" or
                                                                                                                                      	// "cognito-idp-east-1.amazonaws.com/us-east-1_abcdefghi:app_client_id". Up to 25
                                                                                                                                      	// rules can be specified per identity provider.
                                                                                                                                      	RoleMappings map[string]types.RoleMapping
                                                                                                                                      }

                                                                                                                                        Input to the SetIdentityPoolRoles action.

                                                                                                                                        type SetIdentityPoolRolesOutput

                                                                                                                                        type SetIdentityPoolRolesOutput struct {
                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                        }

                                                                                                                                        type TagResourceInput

                                                                                                                                        type TagResourceInput struct {
                                                                                                                                        
                                                                                                                                        	// The Amazon Resource Name (ARN) of the identity pool to assign the tags to.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	ResourceArn *string
                                                                                                                                        
                                                                                                                                        	// The tags to assign to the identity pool.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	Tags map[string]string
                                                                                                                                        }

                                                                                                                                        type TagResourceOutput

                                                                                                                                        type TagResourceOutput struct {
                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                        }

                                                                                                                                        type UnlinkDeveloperIdentityInput

                                                                                                                                        type UnlinkDeveloperIdentityInput struct {
                                                                                                                                        
                                                                                                                                        	// The "domain" by which Cognito will refer to your users.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	DeveloperProviderName *string
                                                                                                                                        
                                                                                                                                        	// A unique ID used by your backend authentication process to identify a user.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	DeveloperUserIdentifier *string
                                                                                                                                        
                                                                                                                                        	// A unique identifier in the format REGION:GUID.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	IdentityId *string
                                                                                                                                        
                                                                                                                                        	// An identity pool ID in the format REGION:GUID.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	IdentityPoolId *string
                                                                                                                                        }

                                                                                                                                          Input to the UnlinkDeveloperIdentity action.

                                                                                                                                          type UnlinkDeveloperIdentityOutput

                                                                                                                                          type UnlinkDeveloperIdentityOutput struct {
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type UnlinkIdentityInput

                                                                                                                                          type UnlinkIdentityInput struct {
                                                                                                                                          
                                                                                                                                          	// A unique identifier in the format REGION:GUID.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	IdentityId *string
                                                                                                                                          
                                                                                                                                          	// A set of optional name-value pairs that map provider names to provider tokens.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Logins map[string]string
                                                                                                                                          
                                                                                                                                          	// Provider names to unlink from this identity.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	LoginsToRemove []string
                                                                                                                                          }

                                                                                                                                            Input to the UnlinkIdentity action.

                                                                                                                                            type UnlinkIdentityOutput

                                                                                                                                            type UnlinkIdentityOutput struct {
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type UntagResourceInput

                                                                                                                                            type UntagResourceInput struct {
                                                                                                                                            
                                                                                                                                            	// The Amazon Resource Name (ARN) of the identity pool that the tags are assigned
                                                                                                                                            	// to.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	ResourceArn *string
                                                                                                                                            
                                                                                                                                            	// The keys of the tags to remove from the user pool.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	TagKeys []string
                                                                                                                                            }

                                                                                                                                            type UntagResourceOutput

                                                                                                                                            type UntagResourceOutput struct {
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type UpdateIdentityPoolInput

                                                                                                                                            type UpdateIdentityPoolInput struct {
                                                                                                                                            
                                                                                                                                            	// TRUE if the identity pool supports unauthenticated logins.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	AllowUnauthenticatedIdentities bool
                                                                                                                                            
                                                                                                                                            	// An identity pool ID in the format REGION:GUID.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	IdentityPoolId *string
                                                                                                                                            
                                                                                                                                            	// A string that you provide.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	IdentityPoolName *string
                                                                                                                                            
                                                                                                                                            	// Enables or disables the Basic (Classic) authentication flow. For more
                                                                                                                                            	// information, see Identity Pools (Federated Identities) Authentication Flow
                                                                                                                                            	// (https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html)
                                                                                                                                            	// in the Amazon Cognito Developer Guide.
                                                                                                                                            	AllowClassicFlow *bool
                                                                                                                                            
                                                                                                                                            	// A list representing an Amazon Cognito user pool and its client ID.
                                                                                                                                            	CognitoIdentityProviders []types.CognitoIdentityProvider
                                                                                                                                            
                                                                                                                                            	// The "domain" by which Cognito will refer to your users.
                                                                                                                                            	DeveloperProviderName *string
                                                                                                                                            
                                                                                                                                            	// The tags that are assigned to the identity pool. 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.
                                                                                                                                            	IdentityPoolTags map[string]string
                                                                                                                                            
                                                                                                                                            	// A list of OpendID Connect provider ARNs.
                                                                                                                                            	OpenIdConnectProviderARNs []string
                                                                                                                                            
                                                                                                                                            	// An array of Amazon Resource Names (ARNs) of the SAML provider for your identity
                                                                                                                                            	// pool.
                                                                                                                                            	SamlProviderARNs []string
                                                                                                                                            
                                                                                                                                            	// Optional key:value pairs mapping provider names to provider app IDs.
                                                                                                                                            	SupportedLoginProviders map[string]string
                                                                                                                                            }

                                                                                                                                              An object representing an Amazon Cognito identity pool.

                                                                                                                                              type UpdateIdentityPoolOutput

                                                                                                                                              type UpdateIdentityPoolOutput struct {
                                                                                                                                              
                                                                                                                                              	// TRUE if the identity pool supports unauthenticated logins.
                                                                                                                                              	//
                                                                                                                                              	// This member is required.
                                                                                                                                              	AllowUnauthenticatedIdentities bool
                                                                                                                                              
                                                                                                                                              	// An identity pool ID in the format REGION:GUID.
                                                                                                                                              	//
                                                                                                                                              	// This member is required.
                                                                                                                                              	IdentityPoolId *string
                                                                                                                                              
                                                                                                                                              	// A string that you provide.
                                                                                                                                              	//
                                                                                                                                              	// This member is required.
                                                                                                                                              	IdentityPoolName *string
                                                                                                                                              
                                                                                                                                              	// Enables or disables the Basic (Classic) authentication flow. For more
                                                                                                                                              	// information, see Identity Pools (Federated Identities) Authentication Flow
                                                                                                                                              	// (https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html)
                                                                                                                                              	// in the Amazon Cognito Developer Guide.
                                                                                                                                              	AllowClassicFlow *bool
                                                                                                                                              
                                                                                                                                              	// A list representing an Amazon Cognito user pool and its client ID.
                                                                                                                                              	CognitoIdentityProviders []types.CognitoIdentityProvider
                                                                                                                                              
                                                                                                                                              	// The "domain" by which Cognito will refer to your users.
                                                                                                                                              	DeveloperProviderName *string
                                                                                                                                              
                                                                                                                                              	// The tags that are assigned to the identity pool. 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.
                                                                                                                                              	IdentityPoolTags map[string]string
                                                                                                                                              
                                                                                                                                              	// A list of OpendID Connect provider ARNs.
                                                                                                                                              	OpenIdConnectProviderARNs []string
                                                                                                                                              
                                                                                                                                              	// An array of Amazon Resource Names (ARNs) of the SAML provider for your identity
                                                                                                                                              	// pool.
                                                                                                                                              	SamlProviderARNs []string
                                                                                                                                              
                                                                                                                                              	// Optional key:value pairs mapping provider names to provider app IDs.
                                                                                                                                              	SupportedLoginProviders map[string]string
                                                                                                                                              
                                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                                              }

                                                                                                                                                An object representing an Amazon Cognito identity pool.

                                                                                                                                                Directories

                                                                                                                                                Path Synopsis
                                                                                                                                                internal