Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AmbiguousRoleResolutionType

type AmbiguousRoleResolutionType string
const (
	AmbiguousRoleResolutionTypeAuthenticatedRole AmbiguousRoleResolutionType = "AuthenticatedRole"
	AmbiguousRoleResolutionTypeDeny              AmbiguousRoleResolutionType = "Deny"
)

    Enum values for AmbiguousRoleResolutionType

    func (AmbiguousRoleResolutionType) Values

      Values returns all known values for AmbiguousRoleResolutionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

      type CognitoIdentityProvider

      type CognitoIdentityProvider struct {
      
      	// The client ID for the Amazon Cognito user pool.
      	ClientId *string
      
      	// The provider name for an Amazon Cognito user pool. For example,
      	// cognito-idp.us-east-1.amazonaws.com/us-east-1_123456789.
      	ProviderName *string
      
      	// TRUE if server-side token validation is enabled for the identity provider’s
      	// token. Once you set ServerSideTokenCheck to TRUE for an identity pool, that
      	// identity pool will check with the integrated user pools to make sure that the
      	// user has not been globally signed out or deleted before the identity pool
      	// provides an OIDC token or AWS credentials for the user. If the user is signed
      	// out or deleted, the identity pool will return a 400 Not Authorized error.
      	ServerSideTokenCheck bool
      }

        A provider representing an Amazon Cognito user pool and its client ID.

        type ConcurrentModificationException

        type ConcurrentModificationException struct {
        	Message *string
        }

          Thrown if there are parallel requests to modify a resource.

          func (*ConcurrentModificationException) Error

          func (*ConcurrentModificationException) ErrorCode

          func (e *ConcurrentModificationException) ErrorCode() string

          func (*ConcurrentModificationException) ErrorFault

          func (*ConcurrentModificationException) ErrorMessage

          func (e *ConcurrentModificationException) ErrorMessage() string

          type Credentials

          type Credentials struct {
          
          	// The Access Key portion of the credentials.
          	AccessKeyId *string
          
          	// The date at which these credentials will expire.
          	Expiration *time.Time
          
          	// The Secret Access Key portion of the credentials
          	SecretKey *string
          
          	// The Session Token portion of the credentials
          	SessionToken *string
          }

            Credentials for the provided identity ID.

            type DeveloperUserAlreadyRegisteredException

            type DeveloperUserAlreadyRegisteredException struct {
            	Message *string
            }

              The provided developer user identifier is already registered with Cognito under a different identity ID.

              func (*DeveloperUserAlreadyRegisteredException) Error

              func (*DeveloperUserAlreadyRegisteredException) ErrorCode

              func (*DeveloperUserAlreadyRegisteredException) ErrorFault

              func (*DeveloperUserAlreadyRegisteredException) ErrorMessage

              type ErrorCode

              type ErrorCode string
              const (
              	ErrorCodeAccessDenied        ErrorCode = "AccessDenied"
              	ErrorCodeInternalServerError ErrorCode = "InternalServerError"
              )

                Enum values for ErrorCode

                func (ErrorCode) Values

                func (ErrorCode) Values() []ErrorCode

                  Values returns all known values for ErrorCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                  type ExternalServiceException

                  type ExternalServiceException struct {
                  	Message *string
                  }

                    An exception thrown when a dependent service such as Facebook or Twitter is not responding

                    func (*ExternalServiceException) Error

                    func (e *ExternalServiceException) Error() string

                    func (*ExternalServiceException) ErrorCode

                    func (e *ExternalServiceException) ErrorCode() string

                    func (*ExternalServiceException) ErrorFault

                    func (e *ExternalServiceException) ErrorFault() smithy.ErrorFault

                    func (*ExternalServiceException) ErrorMessage

                    func (e *ExternalServiceException) ErrorMessage() string

                    type IdentityDescription

                    type IdentityDescription 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
                    }

                      A description of the identity.

                      type IdentityPoolShortDescription

                      type IdentityPoolShortDescription struct {
                      
                      	// An identity pool ID in the format REGION:GUID.
                      	IdentityPoolId *string
                      
                      	// A string that you provide.
                      	IdentityPoolName *string
                      }

                        A description of the identity pool.

                        type InternalErrorException

                        type InternalErrorException struct {
                        	Message *string
                        }

                          Thrown when the service encounters an error during processing the request.

                          func (*InternalErrorException) Error

                          func (e *InternalErrorException) Error() string

                          func (*InternalErrorException) ErrorCode

                          func (e *InternalErrorException) ErrorCode() string

                          func (*InternalErrorException) ErrorFault

                          func (e *InternalErrorException) ErrorFault() smithy.ErrorFault

                          func (*InternalErrorException) ErrorMessage

                          func (e *InternalErrorException) ErrorMessage() string

                          type InvalidIdentityPoolConfigurationException

                          type InvalidIdentityPoolConfigurationException struct {
                          	Message *string
                          }

                            Thrown if the identity pool has no role associated for the given auth type (auth/unauth) or if the AssumeRole fails.

                            func (*InvalidIdentityPoolConfigurationException) Error

                            func (*InvalidIdentityPoolConfigurationException) ErrorCode

                            func (*InvalidIdentityPoolConfigurationException) ErrorFault

                            func (*InvalidIdentityPoolConfigurationException) ErrorMessage

                            type InvalidParameterException

                            type InvalidParameterException struct {
                            	Message *string
                            }

                              Thrown for missing or bad input parameter(s).

                              func (*InvalidParameterException) Error

                              func (e *InvalidParameterException) Error() string

                              func (*InvalidParameterException) ErrorCode

                              func (e *InvalidParameterException) ErrorCode() string

                              func (*InvalidParameterException) ErrorFault

                              func (*InvalidParameterException) ErrorMessage

                              func (e *InvalidParameterException) ErrorMessage() string

                              type LimitExceededException

                              type LimitExceededException struct {
                              	Message *string
                              }

                                Thrown when the total number of user pools has exceeded a preset limit.

                                func (*LimitExceededException) Error

                                func (e *LimitExceededException) Error() string

                                func (*LimitExceededException) ErrorCode

                                func (e *LimitExceededException) ErrorCode() string

                                func (*LimitExceededException) ErrorFault

                                func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                func (*LimitExceededException) ErrorMessage

                                func (e *LimitExceededException) ErrorMessage() string

                                type MappingRule

                                type MappingRule struct {
                                
                                	// The claim name that must be present in the token, for example, "isAdmin" or
                                	// "paid".
                                	//
                                	// This member is required.
                                	Claim *string
                                
                                	// The match condition that specifies how closely the claim value in the IdP token
                                	// must match Value.
                                	//
                                	// This member is required.
                                	MatchType MappingRuleMatchType
                                
                                	// The role ARN.
                                	//
                                	// This member is required.
                                	RoleARN *string
                                
                                	// A brief string that the claim must match, for example, "paid" or "yes".
                                	//
                                	// This member is required.
                                	Value *string
                                }

                                  A rule that maps a claim name, a claim value, and a match type to a role ARN.

                                  type MappingRuleMatchType

                                  type MappingRuleMatchType string
                                  const (
                                  	MappingRuleMatchTypeEquals     MappingRuleMatchType = "Equals"
                                  	MappingRuleMatchTypeContains   MappingRuleMatchType = "Contains"
                                  	MappingRuleMatchTypeStartsWith MappingRuleMatchType = "StartsWith"
                                  	MappingRuleMatchTypeNotEqual   MappingRuleMatchType = "NotEqual"
                                  )

                                    Enum values for MappingRuleMatchType

                                    func (MappingRuleMatchType) Values

                                      Values returns all known values for MappingRuleMatchType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                      type NotAuthorizedException

                                      type NotAuthorizedException struct {
                                      	Message *string
                                      }

                                        Thrown when a user is not authorized to access the requested resource.

                                        func (*NotAuthorizedException) Error

                                        func (e *NotAuthorizedException) Error() string

                                        func (*NotAuthorizedException) ErrorCode

                                        func (e *NotAuthorizedException) ErrorCode() string

                                        func (*NotAuthorizedException) ErrorFault

                                        func (e *NotAuthorizedException) ErrorFault() smithy.ErrorFault

                                        func (*NotAuthorizedException) ErrorMessage

                                        func (e *NotAuthorizedException) ErrorMessage() string

                                        type ResourceConflictException

                                        type ResourceConflictException struct {
                                        	Message *string
                                        }

                                          Thrown when a user tries to use a login which is already linked to another account.

                                          func (*ResourceConflictException) Error

                                          func (e *ResourceConflictException) Error() string

                                          func (*ResourceConflictException) ErrorCode

                                          func (e *ResourceConflictException) ErrorCode() string

                                          func (*ResourceConflictException) ErrorFault

                                          func (*ResourceConflictException) ErrorMessage

                                          func (e *ResourceConflictException) ErrorMessage() string

                                          type ResourceNotFoundException

                                          type ResourceNotFoundException struct {
                                          	Message *string
                                          }

                                            Thrown when the requested resource (for example, a dataset or record) does not exist.

                                            func (*ResourceNotFoundException) Error

                                            func (e *ResourceNotFoundException) Error() string

                                            func (*ResourceNotFoundException) ErrorCode

                                            func (e *ResourceNotFoundException) ErrorCode() string

                                            func (*ResourceNotFoundException) ErrorFault

                                            func (*ResourceNotFoundException) ErrorMessage

                                            func (e *ResourceNotFoundException) ErrorMessage() string

                                            type RoleMapping

                                            type RoleMapping struct {
                                            
                                            	// The role mapping type. Token will use cognito:roles and cognito:preferred_role
                                            	// claims from the Cognito identity provider token to map groups to roles. Rules
                                            	// will attempt to match claims from the token to map to a role.
                                            	//
                                            	// This member is required.
                                            	Type RoleMappingType
                                            
                                            	// If you specify Token or Rules as the Type, AmbiguousRoleResolution is required.
                                            	// Specifies the action to be taken if either no rules match the claim value for
                                            	// the Rules type, or there is no cognito:preferred_role claim and there are
                                            	// multiple cognito:roles matches for the Token type.
                                            	AmbiguousRoleResolution AmbiguousRoleResolutionType
                                            
                                            	// The rules to be used for mapping users to roles. If you specify Rules as the
                                            	// role mapping type, RulesConfiguration is required.
                                            	RulesConfiguration *RulesConfigurationType
                                            }

                                              A role mapping.

                                              type RoleMappingType

                                              type RoleMappingType string
                                              const (
                                              	RoleMappingTypeToken RoleMappingType = "Token"
                                              	RoleMappingTypeRules RoleMappingType = "Rules"
                                              )

                                                Enum values for RoleMappingType

                                                func (RoleMappingType) Values

                                                func (RoleMappingType) Values() []RoleMappingType

                                                  Values returns all known values for RoleMappingType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                  type RulesConfigurationType

                                                  type RulesConfigurationType struct {
                                                  
                                                  	// An array of rules. You can specify up to 25 rules per identity provider. Rules
                                                  	// are evaluated in order. The first one to match specifies the role.
                                                  	//
                                                  	// This member is required.
                                                  	Rules []MappingRule
                                                  }

                                                    A container for rules.

                                                    type TooManyRequestsException

                                                    type TooManyRequestsException struct {
                                                    	Message *string
                                                    }

                                                      Thrown when a request is throttled.

                                                      func (*TooManyRequestsException) Error

                                                      func (e *TooManyRequestsException) Error() string

                                                      func (*TooManyRequestsException) ErrorCode

                                                      func (e *TooManyRequestsException) ErrorCode() string

                                                      func (*TooManyRequestsException) ErrorFault

                                                      func (e *TooManyRequestsException) ErrorFault() smithy.ErrorFault

                                                      func (*TooManyRequestsException) ErrorMessage

                                                      func (e *TooManyRequestsException) ErrorMessage() string

                                                      type UnprocessedIdentityId

                                                      type UnprocessedIdentityId struct {
                                                      
                                                      	// The error code indicating the type of error that occurred.
                                                      	ErrorCode ErrorCode
                                                      
                                                      	// A unique identifier in the format REGION:GUID.
                                                      	IdentityId *string
                                                      }

                                                        An array of UnprocessedIdentityId objects, each of which contains an ErrorCode and IdentityId.