type AmbiguousRoleResolutionType string

const (
	AmbiguousRoleResolutionTypeAuthenticated_role AmbiguousRoleResolutionType = "AuthenticatedRole"
	AmbiguousRoleResolutionTypeDeny               AmbiguousRoleResolutionType = "Deny"
)

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
}

type ConcurrentModificationException struct {
	Message *string
}

type Credentials struct {

	// The Secret Access Key portion of the credentials
	SecretKey *string

	// The Access Key portion of the credentials.
	AccessKeyId *string

	// The date at which these credentials will expire.
	Expiration *time.Time

	// The Session Token portion of the credentials
	SessionToken *string
}

type DeveloperUserAlreadyRegisteredException struct {
	Message *string
}

type ErrorCode string

const (
	ErrorCodeAccess_denied         ErrorCode = "AccessDenied"
	ErrorCodeInternal_server_error ErrorCode = "InternalServerError"
)

type ExternalServiceException struct {
	Message *string
}

type IdentityDescription struct {

	// Date on which the identity was last modified.
	LastModifiedDate *time.Time

	// Date on which the identity was created.
	CreationDate *time.Time

	// A unique identifier in the format REGION:GUID.
	IdentityId *string

	// The provider names.
	Logins []*string
}

type IdentityPoolShortDescription struct {

	// A string that you provide.
	IdentityPoolName *string

	// An identity pool ID in the format REGION:GUID.
	IdentityPoolId *string
}

type InternalErrorException struct {
	Message *string
}

type InvalidIdentityPoolConfigurationException struct {
	Message *string
}

type InvalidParameterException struct {
	Message *string
}

type LimitExceededException struct {
	Message *string
}

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 role ARN.
	//
	// This member is required.
	RoleARN *string

	// The match condition that specifies how closely the claim value in the IdP token
	// must match Value.
	//
	// This member is required.
	MatchType MappingRuleMatchType

	// A brief string that the claim must match, for example, "paid" or "yes".
	//
	// This member is required.
	Value *string
}

type MappingRuleMatchType string

const (
	MappingRuleMatchTypeEquals      MappingRuleMatchType = "Equals"
	MappingRuleMatchTypeContains    MappingRuleMatchType = "Contains"
	MappingRuleMatchTypeStarts_with MappingRuleMatchType = "StartsWith"
	MappingRuleMatchTypeNot_equal   MappingRuleMatchType = "NotEqual"
)

type NotAuthorizedException struct {
	Message *string
}

type ResourceConflictException struct {
	Message *string
}

type ResourceNotFoundException struct {
	Message *string
}

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

	// The rules to be used for mapping users to roles. If you specify Rules as the
	// role mapping type, RulesConfiguration is required.
	RulesConfiguration *RulesConfigurationType

	// 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
}

type RoleMappingType string

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

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
}

type TooManyRequestsException struct {
	Message *string
}

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
}