cognitoidentityprovider

package
v1.3.1-0...-00e2bf9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 3, 2016 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Overview

Package cognitoidentityprovider provides a client for Amazon Cognito Identity Provider.

Index

Examples

Constants

View Source 
const (
	// @enum AliasAttributeType
	AliasAttributeTypePhoneNumber = "phone_number"
	// @enum AliasAttributeType
	AliasAttributeTypeEmail = "email"
	// @enum AliasAttributeType
	AliasAttributeTypePreferredUsername = "preferred_username"
)
View Source 
const (
	// @enum AttributeDataType
	AttributeDataTypeString = "String"
	// @enum AttributeDataType
	AttributeDataTypeNumber = "Number"
	// @enum AttributeDataType
	AttributeDataTypeDateTime = "DateTime"
	// @enum AttributeDataType
	AttributeDataTypeBoolean = "Boolean"
)
View Source 
const (
	// @enum AuthFlowType
	AuthFlowTypeUserSrpAuth = "USER_SRP_AUTH"
	// @enum AuthFlowType
	AuthFlowTypeRefreshTokenAuth = "REFRESH_TOKEN_AUTH"
	// @enum AuthFlowType
	AuthFlowTypeCustomAuth = "CUSTOM_AUTH"
	// @enum AuthFlowType
	AuthFlowTypeAdminNoSrpAuth = "ADMIN_NO_SRP_AUTH"
)
View Source 
const (
	// @enum ChallengeNameType
	ChallengeNameTypeSmsMfa = "SMS_MFA"
	// @enum ChallengeNameType
	ChallengeNameTypePasswordVerifier = "PASSWORD_VERIFIER"
	// @enum ChallengeNameType
	ChallengeNameTypeCustomChallenge = "CUSTOM_CHALLENGE"
	// @enum ChallengeNameType
	ChallengeNameTypeDeviceSrpAuth = "DEVICE_SRP_AUTH"
	// @enum ChallengeNameType
	ChallengeNameTypeDevicePasswordVerifier = "DEVICE_PASSWORD_VERIFIER"
	// @enum ChallengeNameType
	ChallengeNameTypeAdminNoSrpAuth = "ADMIN_NO_SRP_AUTH"
)
View Source 
const (
	// @enum DeliveryMediumType
	DeliveryMediumTypeSms = "SMS"
	// @enum DeliveryMediumType
	DeliveryMediumTypeEmail = "EMAIL"
)
View Source 
const (
	// @enum DeviceRememberedStatusType
	DeviceRememberedStatusTypeRemembered = "remembered"
	// @enum DeviceRememberedStatusType
	DeviceRememberedStatusTypeNotRemembered = "not_remembered"
)
View Source 
const (
	// @enum StatusType
	StatusTypeEnabled = "Enabled"
	// @enum StatusType
	StatusTypeDisabled = "Disabled"
)
View Source 
const (
	// @enum UserPoolMfaType
	UserPoolMfaTypeOff = "OFF"
	// @enum UserPoolMfaType
	UserPoolMfaTypeOn = "ON"
	// @enum UserPoolMfaType
	UserPoolMfaTypeOptional = "OPTIONAL"
)
View Source 
const (
	// @enum UserStatusType
	UserStatusTypeUnconfirmed = "UNCONFIRMED"
	// @enum UserStatusType
	UserStatusTypeConfirmed = "CONFIRMED"
	// @enum UserStatusType
	UserStatusTypeArchived = "ARCHIVED"
	// @enum UserStatusType
	UserStatusTypeCompromised = "COMPROMISED"
	// @enum UserStatusType
	UserStatusTypeUnknown = "UNKNOWN"
	// @enum UserStatusType
	UserStatusTypeResetRequired = "RESET_REQUIRED"
)
View Source 
const (
	// @enum VerifiedAttributeType
	VerifiedAttributeTypePhoneNumber = "phone_number"
	// @enum VerifiedAttributeType
	VerifiedAttributeTypeEmail = "email"
)
View Source 
const (
	// @enum ExplicitAuthFlowsType
	ExplicitAuthFlowsTypeAdminNoSrpAuth = "ADMIN_NO_SRP_AUTH"
)
View Source 
const ServiceName = "cognito-idp"

A ServiceName is the name of the service the client will make API calls to.

Variables

This section is empty.

Functions

This section is empty.

Types

type AddCustomAttributesInput 

type AddCustomAttributesInput struct {

	// An array of custom attributes, such as Mutable and Name.
	CustomAttributes []*SchemaAttributeType `min:"1" type:"list" required:"true"`

	// The user pool ID for the user pool where you want to add custom attributes.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to add custom attributes.

func (AddCustomAttributesInput) GoString 

func (s AddCustomAttributesInput) GoString() string

GoString returns the string representation

func (AddCustomAttributesInput) String 

func (s AddCustomAttributesInput) String() string

String returns the string representation

func (*AddCustomAttributesInput) Validate 

func (s *AddCustomAttributesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AddCustomAttributesOutput 

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

Represents the response from the server for the request to add custom attributes.

func (AddCustomAttributesOutput) GoString 

func (s AddCustomAttributesOutput) GoString() string

GoString returns the string representation

func (AddCustomAttributesOutput) String 

func (s AddCustomAttributesOutput) String() string

String returns the string representation

type AdminConfirmSignUpInput 

type AdminConfirmSignUpInput struct {

	// The user pool ID for which you want to confirm user registration.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name for which you want to confirm user registration.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to confirm user registration.

func (AdminConfirmSignUpInput) GoString 

func (s AdminConfirmSignUpInput) GoString() string

GoString returns the string representation

func (AdminConfirmSignUpInput) String 

func (s AdminConfirmSignUpInput) String() string

String returns the string representation

func (*AdminConfirmSignUpInput) Validate 

func (s *AdminConfirmSignUpInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminConfirmSignUpOutput 

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

Represents the response from the server for the request to confirm registration.

func (AdminConfirmSignUpOutput) GoString 

func (s AdminConfirmSignUpOutput) GoString() string

GoString returns the string representation

func (AdminConfirmSignUpOutput) String 

func (s AdminConfirmSignUpOutput) String() string

String returns the string representation

type AdminDeleteUserAttributesInput 

type AdminDeleteUserAttributesInput struct {

	// An array of strings representing the user attribute names you wish to delete.
	UserAttributeNames []*string `type:"list" required:"true"`

	// The user pool ID for the user pool where you want to delete user attributes.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name of the user from which you would like to delete attributes.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to delete user attributes as an administrator.

func (AdminDeleteUserAttributesInput) GoString 

func (s AdminDeleteUserAttributesInput) GoString() string

GoString returns the string representation

func (AdminDeleteUserAttributesInput) String 

func (s AdminDeleteUserAttributesInput) String() string

String returns the string representation

func (*AdminDeleteUserAttributesInput) Validate 

func (s *AdminDeleteUserAttributesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminDeleteUserAttributesOutput 

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

Represents the response received from the server for a request to delete user attributes.

func (AdminDeleteUserAttributesOutput) GoString 

func (s AdminDeleteUserAttributesOutput) GoString() string

GoString returns the string representation

func (AdminDeleteUserAttributesOutput) String 

func (s AdminDeleteUserAttributesOutput) String() string

String returns the string representation

type AdminDeleteUserInput 

type AdminDeleteUserInput struct {

	// The user pool ID for the user pool where you want to delete the user.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name of the user you wish to delete.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to delete a user as an administrator.

func (AdminDeleteUserInput) GoString 

func (s AdminDeleteUserInput) GoString() string

GoString returns the string representation

func (AdminDeleteUserInput) String 

func (s AdminDeleteUserInput) String() string

String returns the string representation

func (*AdminDeleteUserInput) Validate 

func (s *AdminDeleteUserInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminDeleteUserOutput 

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

func (AdminDeleteUserOutput) GoString 

func (s AdminDeleteUserOutput) GoString() string

GoString returns the string representation

func (AdminDeleteUserOutput) String 

func (s AdminDeleteUserOutput) String() string

String returns the string representation

type AdminDisableUserInput 

type AdminDisableUserInput struct {

	// The user pool ID for the user pool where you want to disable the user.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name of the user you wish to disable.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to disable any user as an administrator.

func (AdminDisableUserInput) GoString 

func (s AdminDisableUserInput) GoString() string

GoString returns the string representation

func (AdminDisableUserInput) String 

func (s AdminDisableUserInput) String() string

String returns the string representation

func (*AdminDisableUserInput) Validate 

func (s *AdminDisableUserInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminDisableUserOutput 

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

Represents the response received from the server to disable the user as an administrator.

func (AdminDisableUserOutput) GoString 

func (s AdminDisableUserOutput) GoString() string

GoString returns the string representation

func (AdminDisableUserOutput) String 

func (s AdminDisableUserOutput) String() string

String returns the string representation

type AdminEnableUserInput 

type AdminEnableUserInput struct {

	// The user pool ID for the user pool where you want to enable the user.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name of the user you wish to ebable.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request that enables the user as an administrator.

func (AdminEnableUserInput) GoString 

func (s AdminEnableUserInput) GoString() string

GoString returns the string representation

func (AdminEnableUserInput) String 

func (s AdminEnableUserInput) String() string

String returns the string representation

func (*AdminEnableUserInput) Validate 

func (s *AdminEnableUserInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminEnableUserOutput 

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

Represents the response from the server for the request to enable a user as an administrator.

func (AdminEnableUserOutput) GoString 

func (s AdminEnableUserOutput) GoString() string

GoString returns the string representation

func (AdminEnableUserOutput) String 

func (s AdminEnableUserOutput) String() string

String returns the string representation

type AdminForgetDeviceInput 

type AdminForgetDeviceInput struct {

	// The device key.
	DeviceKey *string `min:"1" type:"string" required:"true"`

	// The user pool ID.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Sends the forgot device request, as an administrator.

func (AdminForgetDeviceInput) GoString 

func (s AdminForgetDeviceInput) GoString() string

GoString returns the string representation

func (AdminForgetDeviceInput) String 

func (s AdminForgetDeviceInput) String() string

String returns the string representation

func (*AdminForgetDeviceInput) Validate 

func (s *AdminForgetDeviceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminForgetDeviceOutput 

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

func (AdminForgetDeviceOutput) GoString 

func (s AdminForgetDeviceOutput) GoString() string

GoString returns the string representation

func (AdminForgetDeviceOutput) String 

func (s AdminForgetDeviceOutput) String() string

String returns the string representation

type AdminGetDeviceInput 

type AdminGetDeviceInput struct {

	// The device key.
	DeviceKey *string `min:"1" type:"string" required:"true"`

	// The user pool ID.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to get the device, as an administrator.

func (AdminGetDeviceInput) GoString 

func (s AdminGetDeviceInput) GoString() string

GoString returns the string representation

func (AdminGetDeviceInput) String 

func (s AdminGetDeviceInput) String() string

String returns the string representation

func (*AdminGetDeviceInput) Validate 

func (s *AdminGetDeviceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminGetDeviceOutput 

type AdminGetDeviceOutput struct {

	// The device.
	Device *DeviceType `type:"structure" required:"true"`
	// contains filtered or unexported fields
}

Gets the device response, as an administrator.

func (AdminGetDeviceOutput) GoString 

func (s AdminGetDeviceOutput) GoString() string

GoString returns the string representation

func (AdminGetDeviceOutput) String 

func (s AdminGetDeviceOutput) String() string

String returns the string representation

type AdminGetUserInput 

type AdminGetUserInput struct {

	// The user pool ID for the user pool where you want to get information about
	// the user.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name of the user you wish to retrieve.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to get the specified user as an administrator.

func (AdminGetUserInput) GoString 

func (s AdminGetUserInput) GoString() string

GoString returns the string representation

func (AdminGetUserInput) String 

func (s AdminGetUserInput) String() string

String returns the string representation

func (*AdminGetUserInput) Validate 

func (s *AdminGetUserInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminGetUserOutput 

type AdminGetUserOutput struct {

	// Indicates that the status is enabled.
	Enabled *bool `type:"boolean"`

	// Specifies the options for MFA (e.g., email or phone number).
	MFAOptions []*MFAOptionType `type:"list"`

	// An array of name-value pairs representing user attributes.
	UserAttributes []*AttributeType `type:"list"`

	// The date the user was created.
	UserCreateDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The date the user was last modified.
	UserLastModifiedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The user status. Can be one of the following:
	//
	//  UNCONFIRMED - User has been created but not confirmed. CONFIRMED - User
	// has been confirmed. ARCHIVED - User is no longer active. COMPROMISED - User
	// is disabled due to a potential security threat. UNKNOWN - User status is
	// not known.
	UserStatus *string `type:"string" enum:"UserStatusType"`

	// The user name of the user about whom you are receiving information.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the response from the server from the request to get the specified user as an administrator.

func (AdminGetUserOutput) GoString 

func (s AdminGetUserOutput) GoString() string

GoString returns the string representation

func (AdminGetUserOutput) String 

func (s AdminGetUserOutput) String() string

String returns the string representation

type AdminInitiateAuthInput 

type AdminInitiateAuthInput struct {

	// The authentication flow.
	AuthFlow *string `type:"string" required:"true" enum:"AuthFlowType"`

	// The authentication parameters.
	AuthParameters map[string]*string `type:"map"`

	// The client app ID.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The client app metadata.
	ClientMetadata map[string]*string `type:"map"`

	// The ID of the Amazon Cognito user pool.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Initiates the authorization request, as an administrator.

func (AdminInitiateAuthInput) GoString 

func (s AdminInitiateAuthInput) GoString() string

GoString returns the string representation

func (AdminInitiateAuthInput) String 

func (s AdminInitiateAuthInput) String() string

String returns the string representation

func (*AdminInitiateAuthInput) Validate 

func (s *AdminInitiateAuthInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminInitiateAuthOutput 

type AdminInitiateAuthOutput struct {

	// The result type of the authentication result.
	AuthenticationResult *AuthenticationResultType `type:"structure"`

	// The name of the challenge.
	ChallengeName *string `type:"string" enum:"ChallengeNameType"`

	// The challenge parameters.
	ChallengeParameters map[string]*string `type:"map"`

	// The session.
	Session *string `min:"20" type:"string"`
	// contains filtered or unexported fields
}

Initiates the authentication response, as an administrator.

func (AdminInitiateAuthOutput) GoString 

func (s AdminInitiateAuthOutput) GoString() string

GoString returns the string representation

func (AdminInitiateAuthOutput) String 

func (s AdminInitiateAuthOutput) String() string

String returns the string representation

type AdminListDevicesInput 

type AdminListDevicesInput struct {

	// The limit of the devices request.
	Limit *int64 `type:"integer"`

	// The pagination token.
	PaginationToken *string `min:"1" type:"string"`

	// The user pool ID.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to list devices, as an administrator.

func (AdminListDevicesInput) GoString 

func (s AdminListDevicesInput) GoString() string

GoString returns the string representation

func (AdminListDevicesInput) String 

func (s AdminListDevicesInput) String() string

String returns the string representation

func (*AdminListDevicesInput) Validate 

func (s *AdminListDevicesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminListDevicesOutput 

type AdminListDevicesOutput struct {

	// The devices in the list of devices response.
	Devices []*DeviceType `type:"list"`

	// The pagination token.
	PaginationToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

Lists the device's response, as an administrator.

func (AdminListDevicesOutput) GoString 

func (s AdminListDevicesOutput) GoString() string

GoString returns the string representation

func (AdminListDevicesOutput) String 

func (s AdminListDevicesOutput) String() string

String returns the string representation

type AdminResetUserPasswordInput 

type AdminResetUserPasswordInput struct {

	// The user pool ID for the user pool where you want to reset the user's password.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name of the user whose password you wish to reset.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to reset a user's password as an administrator.

func (AdminResetUserPasswordInput) GoString 

func (s AdminResetUserPasswordInput) GoString() string

GoString returns the string representation

func (AdminResetUserPasswordInput) String 

func (s AdminResetUserPasswordInput) String() string

String returns the string representation

func (*AdminResetUserPasswordInput) Validate 

func (s *AdminResetUserPasswordInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminResetUserPasswordOutput 

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

Represents the response from the server to reset a user password as an administrator.

func (AdminResetUserPasswordOutput) GoString 

func (s AdminResetUserPasswordOutput) GoString() string

GoString returns the string representation

func (AdminResetUserPasswordOutput) String 

func (s AdminResetUserPasswordOutput) String() string

String returns the string representation

type AdminRespondToAuthChallengeInput 

type AdminRespondToAuthChallengeInput struct {

	// The name of the challenge.
	ChallengeName *string `type:"string" required:"true" enum:"ChallengeNameType"`

	// The challenge response.
	ChallengeResponses map[string]*string `type:"map"`

	// The client ID.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The session.
	Session *string `min:"20" type:"string"`

	// The ID of the Amazon Cognito user pool.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

The request to respond to the authentication challenge, as an administrator.

func (AdminRespondToAuthChallengeInput) GoString 

func (s AdminRespondToAuthChallengeInput) GoString() string

GoString returns the string representation

func (AdminRespondToAuthChallengeInput) String 

func (s AdminRespondToAuthChallengeInput) String() string

String returns the string representation

func (*AdminRespondToAuthChallengeInput) Validate 

func (s *AdminRespondToAuthChallengeInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminRespondToAuthChallengeOutput 

type AdminRespondToAuthChallengeOutput struct {

	// The result type of the authentication result.
	AuthenticationResult *AuthenticationResultType `type:"structure"`

	// The name of the challenge.
	ChallengeName *string `type:"string" enum:"ChallengeNameType"`

	// The challenge parameters.
	ChallengeParameters map[string]*string `type:"map"`

	// The session.
	Session *string `min:"20" type:"string"`
	// contains filtered or unexported fields
}

Responds to the authentication challenge, as an administrator.

func (AdminRespondToAuthChallengeOutput) GoString 

func (s AdminRespondToAuthChallengeOutput) GoString() string

GoString returns the string representation

func (AdminRespondToAuthChallengeOutput) String 

func (s AdminRespondToAuthChallengeOutput) String() string

String returns the string representation

type AdminSetUserSettingsInput 

type AdminSetUserSettingsInput struct {

	// Specifies the options for MFA (e.g., email or phone number).
	MFAOptions []*MFAOptionType `type:"list" required:"true"`

	// The user pool ID for the user pool where you want to set the user's settings,
	// such as MFA options.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name of the user for whom you wish to set user settings.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to set user settings as an administrator.

func (AdminSetUserSettingsInput) GoString 

func (s AdminSetUserSettingsInput) GoString() string

GoString returns the string representation

func (AdminSetUserSettingsInput) String 

func (s AdminSetUserSettingsInput) String() string

String returns the string representation

func (*AdminSetUserSettingsInput) Validate 

func (s *AdminSetUserSettingsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminSetUserSettingsOutput 

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

Represents the response from the server to set user settings as an administrator.

func (AdminSetUserSettingsOutput) GoString 

func (s AdminSetUserSettingsOutput) GoString() string

GoString returns the string representation

func (AdminSetUserSettingsOutput) String 

func (s AdminSetUserSettingsOutput) String() string

String returns the string representation

type AdminUpdateDeviceStatusInput 

type AdminUpdateDeviceStatusInput struct {

	// The device key.
	DeviceKey *string `min:"1" type:"string" required:"true"`

	// The status indicating whether a device has been remembered or not.
	DeviceRememberedStatus *string `type:"string" enum:"DeviceRememberedStatusType"`

	// The user pool ID>
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

The request to update the device status, as an administrator.

func (AdminUpdateDeviceStatusInput) GoString 

func (s AdminUpdateDeviceStatusInput) GoString() string

GoString returns the string representation

func (AdminUpdateDeviceStatusInput) String 

func (s AdminUpdateDeviceStatusInput) String() string

String returns the string representation

func (*AdminUpdateDeviceStatusInput) Validate 

func (s *AdminUpdateDeviceStatusInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminUpdateDeviceStatusOutput 

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

The status response from the request to update the device, as an administrator.

func (AdminUpdateDeviceStatusOutput) GoString 

func (s AdminUpdateDeviceStatusOutput) GoString() string

GoString returns the string representation

func (AdminUpdateDeviceStatusOutput) String 

func (s AdminUpdateDeviceStatusOutput) String() string

String returns the string representation

type AdminUpdateUserAttributesInput 

type AdminUpdateUserAttributesInput struct {

	// An array of name-value pairs representing user attributes.
	UserAttributes []*AttributeType `type:"list" required:"true"`

	// The user pool ID for the user pool where you want to update user attributes.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name of the user for whom you want to update user attributes.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to update the user's attributes as an administrator.

func (AdminUpdateUserAttributesInput) GoString 

func (s AdminUpdateUserAttributesInput) GoString() string

GoString returns the string representation

func (AdminUpdateUserAttributesInput) String 

func (s AdminUpdateUserAttributesInput) String() string

String returns the string representation

func (*AdminUpdateUserAttributesInput) Validate 

func (s *AdminUpdateUserAttributesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminUpdateUserAttributesOutput 

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

Represents the response from the server for the request to update user attributes as an administrator.

func (AdminUpdateUserAttributesOutput) GoString 

func (s AdminUpdateUserAttributesOutput) GoString() string

GoString returns the string representation

func (AdminUpdateUserAttributesOutput) String 

func (s AdminUpdateUserAttributesOutput) String() string

String returns the string representation

type AdminUserGlobalSignOutInput 

type AdminUserGlobalSignOutInput struct {

	// The user pool ID.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The user name.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

The request to sign out of all devices, as an administrator.

func (AdminUserGlobalSignOutInput) GoString 

func (s AdminUserGlobalSignOutInput) GoString() string

GoString returns the string representation

func (AdminUserGlobalSignOutInput) String 

func (s AdminUserGlobalSignOutInput) String() string

String returns the string representation

func (*AdminUserGlobalSignOutInput) Validate 

func (s *AdminUserGlobalSignOutInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AdminUserGlobalSignOutOutput 

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

The global signot response, as an administrator.

func (AdminUserGlobalSignOutOutput) GoString 

func (s AdminUserGlobalSignOutOutput) GoString() string

GoString returns the string representation

func (AdminUserGlobalSignOutOutput) String 

func (s AdminUserGlobalSignOutOutput) String() string

String returns the string representation

type AttributeType 

type AttributeType struct {

	// The name of the attribute.
	Name *string `min:"1" type:"string" required:"true"`

	// The value of the attribute.
	Value *string `type:"string"`
	// contains filtered or unexported fields
}

Specifies whether the attribute is standard or custom.

func (AttributeType) GoString 

func (s AttributeType) GoString() string

GoString returns the string representation

func (AttributeType) String 

func (s AttributeType) String() string

String returns the string representation

func (*AttributeType) Validate 

func (s *AttributeType) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type AuthenticationResultType 

type AuthenticationResultType struct {

	// The access token of the authentication result.
	AccessToken *string `type:"string"`

	// The expiration period of the authentication result.
	ExpiresIn *int64 `type:"integer"`

	// The ID token of the authentication result.
	IdToken *string `type:"string"`

	// The new device metadata from an authentication result.
	NewDeviceMetadata *NewDeviceMetadataType `type:"structure"`

	// The refresh token of the authentication result.
	RefreshToken *string `type:"string"`

	// The token type of the authentication result.
	TokenType *string `type:"string"`
	// contains filtered or unexported fields
}

The result type of the authentication result.

func (AuthenticationResultType) GoString 

func (s AuthenticationResultType) GoString() string

GoString returns the string representation

func (AuthenticationResultType) String 

func (s AuthenticationResultType) String() string

String returns the string representation

type ChangePasswordInput 

type ChangePasswordInput struct {

	// The access token in the change password request.
	AccessToken *string `type:"string"`

	// The old password in the change password request.
	PreviousPassword *string `min:"6" type:"string" required:"true"`

	// The new password in the change password request.
	ProposedPassword *string `min:"6" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to change a user password.

func (ChangePasswordInput) GoString 

func (s ChangePasswordInput) GoString() string

GoString returns the string representation

func (ChangePasswordInput) String 

func (s ChangePasswordInput) String() string

String returns the string representation

func (*ChangePasswordInput) Validate 

func (s *ChangePasswordInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ChangePasswordOutput 

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

The response from the server to the change password request.

func (ChangePasswordOutput) GoString 

func (s ChangePasswordOutput) GoString() string

GoString returns the string representation

func (ChangePasswordOutput) String 

func (s ChangePasswordOutput) String() string

String returns the string representation

type CodeDeliveryDetailsType 

type CodeDeliveryDetailsType struct {

	// The name of the attribute in the code delivery details type.
	AttributeName *string `min:"1" type:"string"`

	// The delivery medium (email message or phone number).
	DeliveryMedium *string `type:"string" enum:"DeliveryMediumType"`

	// The destination for the code delivery details.
	Destination *string `type:"string"`
	// contains filtered or unexported fields
}

The type of code delivery details being returned from the server.

func (CodeDeliveryDetailsType) GoString 

func (s CodeDeliveryDetailsType) GoString() string

GoString returns the string representation

func (CodeDeliveryDetailsType) String 

func (s CodeDeliveryDetailsType) String() string

String returns the string representation

type CognitoIdentityProvider 

type CognitoIdentityProvider struct {
	*client.Client
}

You can create a user pool in Amazon Cognito Identity to manage directories and users. You can authenticate a user to obtain tokens related to user identity and access policies.

This API reference provides information about user pools in Amazon Cognito Identity.

For more information, see Amazon Cognito (https://aws.amazon.com/cognito/). The service client's operations are safe to be used concurrently. It is not safe to mutate any of the client's properties though.

func New 

func New(p client.ConfigProvider, cfgs ...*aws.Config) *CognitoIdentityProvider

New creates a new instance of the CognitoIdentityProvider client with a session. If additional configuration is needed for the client instance use the optional aws.Config parameter to add your extra config.

Example: 

// Create a CognitoIdentityProvider client from just a session.
svc := cognitoidentityprovider.New(mySession)

// Create a CognitoIdentityProvider client with additional configuration
svc := cognitoidentityprovider.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func (*CognitoIdentityProvider) AddCustomAttributes 

func (c *CognitoIdentityProvider) AddCustomAttributes(input *AddCustomAttributesInput) (*AddCustomAttributesOutput, error)

Adds additional user attributes to the user pool schema.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AddCustomAttributesInput{
		CustomAttributes: []*cognitoidentityprovider.SchemaAttributeType{ // Required
			{ // Required
				AttributeDataType:      aws.String("AttributeDataType"),
				DeveloperOnlyAttribute: aws.Bool(true),
				Mutable:                aws.Bool(true),
				Name:                   aws.String("CustomAttributeNameType"),
				NumberAttributeConstraints: &cognitoidentityprovider.NumberAttributeConstraintsType{
					MaxValue: aws.String("StringType"),
					MinValue: aws.String("StringType"),
				},
				Required: aws.Bool(true),
				StringAttributeConstraints: &cognitoidentityprovider.StringAttributeConstraintsType{
					MaxLength: aws.String("StringType"),
					MinLength: aws.String("StringType"),
				},
			},
			// More values...
		},
		UserPoolId: aws.String("UserPoolIdType"), // Required
	}
	resp, err := svc.AddCustomAttributes(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AddCustomAttributesRequest 

func (c *CognitoIdentityProvider) AddCustomAttributesRequest(input *AddCustomAttributesInput) (req *request.Request, output *AddCustomAttributesOutput)

AddCustomAttributesRequest generates a "aws/request.Request" representing the client's request for the AddCustomAttributes operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AddCustomAttributes method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AddCustomAttributesRequest method.
req, resp := client.AddCustomAttributesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminConfirmSignUp 

func (c *CognitoIdentityProvider) AdminConfirmSignUp(input *AdminConfirmSignUpInput) (*AdminConfirmSignUpOutput, error)

Confirms user registration as an admin without using a confirmation code. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminConfirmSignUpInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminConfirmSignUp(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminConfirmSignUpRequest 

func (c *CognitoIdentityProvider) AdminConfirmSignUpRequest(input *AdminConfirmSignUpInput) (req *request.Request, output *AdminConfirmSignUpOutput)

AdminConfirmSignUpRequest generates a "aws/request.Request" representing the client's request for the AdminConfirmSignUp operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminConfirmSignUp method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminConfirmSignUpRequest method.
req, resp := client.AdminConfirmSignUpRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminDeleteUser 

func (c *CognitoIdentityProvider) AdminDeleteUser(input *AdminDeleteUserInput) (*AdminDeleteUserOutput, error)

Deletes a user as an administrator. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminDeleteUserInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminDeleteUser(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminDeleteUserAttributes 

func (c *CognitoIdentityProvider) AdminDeleteUserAttributes(input *AdminDeleteUserAttributesInput) (*AdminDeleteUserAttributesOutput, error)

Deletes the user attributes in a user pool as an administrator. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminDeleteUserAttributesInput{
		UserAttributeNames: []*string{ // Required
			aws.String("AttributeNameType"), // Required
			// More values...
		},
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminDeleteUserAttributes(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminDeleteUserAttributesRequest 

func (c *CognitoIdentityProvider) AdminDeleteUserAttributesRequest(input *AdminDeleteUserAttributesInput) (req *request.Request, output *AdminDeleteUserAttributesOutput)

AdminDeleteUserAttributesRequest generates a "aws/request.Request" representing the client's request for the AdminDeleteUserAttributes operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminDeleteUserAttributes method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminDeleteUserAttributesRequest method.
req, resp := client.AdminDeleteUserAttributesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminDeleteUserRequest 

func (c *CognitoIdentityProvider) AdminDeleteUserRequest(input *AdminDeleteUserInput) (req *request.Request, output *AdminDeleteUserOutput)

AdminDeleteUserRequest generates a "aws/request.Request" representing the client's request for the AdminDeleteUser operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminDeleteUser method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminDeleteUserRequest method.
req, resp := client.AdminDeleteUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminDisableUser 

func (c *CognitoIdentityProvider) AdminDisableUser(input *AdminDisableUserInput) (*AdminDisableUserOutput, error)

Disables the specified user as an administrator. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminDisableUserInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminDisableUser(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminDisableUserRequest 

func (c *CognitoIdentityProvider) AdminDisableUserRequest(input *AdminDisableUserInput) (req *request.Request, output *AdminDisableUserOutput)

AdminDisableUserRequest generates a "aws/request.Request" representing the client's request for the AdminDisableUser operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminDisableUser method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminDisableUserRequest method.
req, resp := client.AdminDisableUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminEnableUser 

func (c *CognitoIdentityProvider) AdminEnableUser(input *AdminEnableUserInput) (*AdminEnableUserOutput, error)

Enables the specified user as an administrator. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminEnableUserInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminEnableUser(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminEnableUserRequest 

func (c *CognitoIdentityProvider) AdminEnableUserRequest(input *AdminEnableUserInput) (req *request.Request, output *AdminEnableUserOutput)

AdminEnableUserRequest generates a "aws/request.Request" representing the client's request for the AdminEnableUser operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminEnableUser method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminEnableUserRequest method.
req, resp := client.AdminEnableUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminForgetDevice 

func (c *CognitoIdentityProvider) AdminForgetDevice(input *AdminForgetDeviceInput) (*AdminForgetDeviceOutput, error)

Forgets the device, as an administrator.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminForgetDeviceInput{
		DeviceKey:  aws.String("DeviceKeyType"),  // Required
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminForgetDevice(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminForgetDeviceRequest 

func (c *CognitoIdentityProvider) AdminForgetDeviceRequest(input *AdminForgetDeviceInput) (req *request.Request, output *AdminForgetDeviceOutput)

AdminForgetDeviceRequest generates a "aws/request.Request" representing the client's request for the AdminForgetDevice operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminForgetDevice method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminForgetDeviceRequest method.
req, resp := client.AdminForgetDeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminGetDevice 

func (c *CognitoIdentityProvider) AdminGetDevice(input *AdminGetDeviceInput) (*AdminGetDeviceOutput, error)

Gets the device, as an administrator.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminGetDeviceInput{
		DeviceKey:  aws.String("DeviceKeyType"),  // Required
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminGetDevice(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminGetDeviceRequest 

func (c *CognitoIdentityProvider) AdminGetDeviceRequest(input *AdminGetDeviceInput) (req *request.Request, output *AdminGetDeviceOutput)

AdminGetDeviceRequest generates a "aws/request.Request" representing the client's request for the AdminGetDevice operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminGetDevice method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminGetDeviceRequest method.
req, resp := client.AdminGetDeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminGetUser 

func (c *CognitoIdentityProvider) AdminGetUser(input *AdminGetUserInput) (*AdminGetUserOutput, error)

Gets the specified user by user name in a user pool as an administrator. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminGetUserInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminGetUser(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminGetUserRequest 

func (c *CognitoIdentityProvider) AdminGetUserRequest(input *AdminGetUserInput) (req *request.Request, output *AdminGetUserOutput)

AdminGetUserRequest generates a "aws/request.Request" representing the client's request for the AdminGetUser operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminGetUser method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminGetUserRequest method.
req, resp := client.AdminGetUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminInitiateAuth 

func (c *CognitoIdentityProvider) AdminInitiateAuth(input *AdminInitiateAuthInput) (*AdminInitiateAuthOutput, error)

Initiates the authentication flow, as an administrator.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminInitiateAuthInput{
		AuthFlow:   aws.String("AuthFlowType"),   // Required
		ClientId:   aws.String("ClientIdType"),   // Required
		UserPoolId: aws.String("UserPoolIdType"), // Required
		AuthParameters: map[string]*string{
			"Key": aws.String("StringType"), // Required
			// More values...
		},
		ClientMetadata: map[string]*string{
			"Key": aws.String("StringType"), // Required
			// More values...
		},
	}
	resp, err := svc.AdminInitiateAuth(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminInitiateAuthRequest 

func (c *CognitoIdentityProvider) AdminInitiateAuthRequest(input *AdminInitiateAuthInput) (req *request.Request, output *AdminInitiateAuthOutput)

AdminInitiateAuthRequest generates a "aws/request.Request" representing the client's request for the AdminInitiateAuth operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminInitiateAuth method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminInitiateAuthRequest method.
req, resp := client.AdminInitiateAuthRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminListDevices 

func (c *CognitoIdentityProvider) AdminListDevices(input *AdminListDevicesInput) (*AdminListDevicesOutput, error)

Lists devices, as an administrator.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminListDevicesInput{
		UserPoolId:      aws.String("UserPoolIdType"), // Required
		Username:        aws.String("UsernameType"),   // Required
		Limit:           aws.Int64(1),
		PaginationToken: aws.String("SearchPaginationTokenType"),
	}
	resp, err := svc.AdminListDevices(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminListDevicesRequest 

func (c *CognitoIdentityProvider) AdminListDevicesRequest(input *AdminListDevicesInput) (req *request.Request, output *AdminListDevicesOutput)

AdminListDevicesRequest generates a "aws/request.Request" representing the client's request for the AdminListDevices operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminListDevices method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminListDevicesRequest method.
req, resp := client.AdminListDevicesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminResetUserPassword 

func (c *CognitoIdentityProvider) AdminResetUserPassword(input *AdminResetUserPasswordInput) (*AdminResetUserPasswordOutput, error)

Resets the specified user's password in a user pool as an administrator. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminResetUserPasswordInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminResetUserPassword(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminResetUserPasswordRequest 

func (c *CognitoIdentityProvider) AdminResetUserPasswordRequest(input *AdminResetUserPasswordInput) (req *request.Request, output *AdminResetUserPasswordOutput)

AdminResetUserPasswordRequest generates a "aws/request.Request" representing the client's request for the AdminResetUserPassword operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminResetUserPassword method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminResetUserPasswordRequest method.
req, resp := client.AdminResetUserPasswordRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminRespondToAuthChallenge 

func (c *CognitoIdentityProvider) AdminRespondToAuthChallenge(input *AdminRespondToAuthChallengeInput) (*AdminRespondToAuthChallengeOutput, error)

Responds to an authentication challenge, as an administrator.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminRespondToAuthChallengeInput{
		ChallengeName: aws.String("ChallengeNameType"), // Required
		ClientId:      aws.String("ClientIdType"),      // Required
		UserPoolId:    aws.String("UserPoolIdType"),    // Required
		ChallengeResponses: map[string]*string{
			"Key": aws.String("StringType"), // Required
			// More values...
		},
		Session: aws.String("SessionType"),
	}
	resp, err := svc.AdminRespondToAuthChallenge(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminRespondToAuthChallengeRequest 

func (c *CognitoIdentityProvider) AdminRespondToAuthChallengeRequest(input *AdminRespondToAuthChallengeInput) (req *request.Request, output *AdminRespondToAuthChallengeOutput)

AdminRespondToAuthChallengeRequest generates a "aws/request.Request" representing the client's request for the AdminRespondToAuthChallenge operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminRespondToAuthChallenge method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminRespondToAuthChallengeRequest method.
req, resp := client.AdminRespondToAuthChallengeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminSetUserSettings 

func (c *CognitoIdentityProvider) AdminSetUserSettings(input *AdminSetUserSettingsInput) (*AdminSetUserSettingsOutput, error)

Sets all the user settings for a specified user name. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminSetUserSettingsInput{
		MFAOptions: []*cognitoidentityprovider.MFAOptionType{ // Required
			{ // Required
				AttributeName:  aws.String("AttributeNameType"),
				DeliveryMedium: aws.String("DeliveryMediumType"),
			},
			// More values...
		},
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminSetUserSettings(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminSetUserSettingsRequest 

func (c *CognitoIdentityProvider) AdminSetUserSettingsRequest(input *AdminSetUserSettingsInput) (req *request.Request, output *AdminSetUserSettingsOutput)

AdminSetUserSettingsRequest generates a "aws/request.Request" representing the client's request for the AdminSetUserSettings operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminSetUserSettings method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminSetUserSettingsRequest method.
req, resp := client.AdminSetUserSettingsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminUpdateDeviceStatus 

func (c *CognitoIdentityProvider) AdminUpdateDeviceStatus(input *AdminUpdateDeviceStatusInput) (*AdminUpdateDeviceStatusOutput, error)

Updates the device status as an administrator.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminUpdateDeviceStatusInput{
		DeviceKey:              aws.String("DeviceKeyType"),  // Required
		UserPoolId:             aws.String("UserPoolIdType"), // Required
		Username:               aws.String("UsernameType"),   // Required
		DeviceRememberedStatus: aws.String("DeviceRememberedStatusType"),
	}
	resp, err := svc.AdminUpdateDeviceStatus(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminUpdateDeviceStatusRequest 

func (c *CognitoIdentityProvider) AdminUpdateDeviceStatusRequest(input *AdminUpdateDeviceStatusInput) (req *request.Request, output *AdminUpdateDeviceStatusOutput)

AdminUpdateDeviceStatusRequest generates a "aws/request.Request" representing the client's request for the AdminUpdateDeviceStatus operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminUpdateDeviceStatus method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminUpdateDeviceStatusRequest method.
req, resp := client.AdminUpdateDeviceStatusRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminUpdateUserAttributes 

func (c *CognitoIdentityProvider) AdminUpdateUserAttributes(input *AdminUpdateUserAttributesInput) (*AdminUpdateUserAttributesOutput, error)

Updates the specified user's attributes, including developer attributes, as an administrator. Works on any user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminUpdateUserAttributesInput{
		UserAttributes: []*cognitoidentityprovider.AttributeType{ // Required
			{ // Required
				Name:  aws.String("AttributeNameType"), // Required
				Value: aws.String("AttributeValueType"),
			},
			// More values...
		},
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminUpdateUserAttributes(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminUpdateUserAttributesRequest 

func (c *CognitoIdentityProvider) AdminUpdateUserAttributesRequest(input *AdminUpdateUserAttributesInput) (req *request.Request, output *AdminUpdateUserAttributesOutput)

AdminUpdateUserAttributesRequest generates a "aws/request.Request" representing the client's request for the AdminUpdateUserAttributes operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminUpdateUserAttributes method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminUpdateUserAttributesRequest method.
req, resp := client.AdminUpdateUserAttributesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) AdminUserGlobalSignOut 

func (c *CognitoIdentityProvider) AdminUserGlobalSignOut(input *AdminUserGlobalSignOutInput) (*AdminUserGlobalSignOutOutput, error)

Signs out users from all devices, as an administrator.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.AdminUserGlobalSignOutInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		Username:   aws.String("UsernameType"),   // Required
	}
	resp, err := svc.AdminUserGlobalSignOut(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) AdminUserGlobalSignOutRequest 

func (c *CognitoIdentityProvider) AdminUserGlobalSignOutRequest(input *AdminUserGlobalSignOutInput) (req *request.Request, output *AdminUserGlobalSignOutOutput)

AdminUserGlobalSignOutRequest generates a "aws/request.Request" representing the client's request for the AdminUserGlobalSignOut operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the AdminUserGlobalSignOut method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the AdminUserGlobalSignOutRequest method.
req, resp := client.AdminUserGlobalSignOutRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ChangePassword 

func (c *CognitoIdentityProvider) ChangePassword(input *ChangePasswordInput) (*ChangePasswordOutput, error)

Changes the password for a specified user in a user pool.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ChangePasswordInput{
		PreviousPassword: aws.String("PasswordType"), // Required
		ProposedPassword: aws.String("PasswordType"), // Required
		AccessToken:      aws.String("TokenModelType"),
	}
	resp, err := svc.ChangePassword(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ChangePasswordRequest 

func (c *CognitoIdentityProvider) ChangePasswordRequest(input *ChangePasswordInput) (req *request.Request, output *ChangePasswordOutput)

ChangePasswordRequest generates a "aws/request.Request" representing the client's request for the ChangePassword operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ChangePassword method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ChangePasswordRequest method.
req, resp := client.ChangePasswordRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ConfirmDevice 

func (c *CognitoIdentityProvider) ConfirmDevice(input *ConfirmDeviceInput) (*ConfirmDeviceOutput, error)

Confirms tracking of the device. This API call is the call that beings device tracking.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ConfirmDeviceInput{
		AccessToken: aws.String("TokenModelType"), // Required
		DeviceKey:   aws.String("DeviceKeyType"),  // Required
		DeviceName:  aws.String("DeviceNameType"),
		DeviceSecretVerifierConfig: &cognitoidentityprovider.DeviceSecretVerifierConfigType{
			PasswordVerifier: aws.String("StringType"),
			Salt:             aws.String("StringType"),
		},
	}
	resp, err := svc.ConfirmDevice(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ConfirmDeviceRequest 

func (c *CognitoIdentityProvider) ConfirmDeviceRequest(input *ConfirmDeviceInput) (req *request.Request, output *ConfirmDeviceOutput)

ConfirmDeviceRequest generates a "aws/request.Request" representing the client's request for the ConfirmDevice operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ConfirmDevice method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ConfirmDeviceRequest method.
req, resp := client.ConfirmDeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ConfirmForgotPassword 

func (c *CognitoIdentityProvider) ConfirmForgotPassword(input *ConfirmForgotPasswordInput) (*ConfirmForgotPasswordOutput, error)

Allows a user to enter a code provided when they reset their password to update their password.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ConfirmForgotPasswordInput{
		ClientId:         aws.String("ClientIdType"),         // Required
		ConfirmationCode: aws.String("ConfirmationCodeType"), // Required
		Password:         aws.String("PasswordType"),         // Required
		Username:         aws.String("UsernameType"),         // Required
		SecretHash:       aws.String("SecretHashType"),
	}
	resp, err := svc.ConfirmForgotPassword(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ConfirmForgotPasswordRequest 

func (c *CognitoIdentityProvider) ConfirmForgotPasswordRequest(input *ConfirmForgotPasswordInput) (req *request.Request, output *ConfirmForgotPasswordOutput)

ConfirmForgotPasswordRequest generates a "aws/request.Request" representing the client's request for the ConfirmForgotPassword operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ConfirmForgotPassword method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ConfirmForgotPasswordRequest method.
req, resp := client.ConfirmForgotPasswordRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ConfirmSignUp 

func (c *CognitoIdentityProvider) ConfirmSignUp(input *ConfirmSignUpInput) (*ConfirmSignUpOutput, error)

Confirms registration of a user and handles the existing alias from a previous user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ConfirmSignUpInput{
		ClientId:           aws.String("ClientIdType"),         // Required
		ConfirmationCode:   aws.String("ConfirmationCodeType"), // Required
		Username:           aws.String("UsernameType"),         // Required
		ForceAliasCreation: aws.Bool(true),
		SecretHash:         aws.String("SecretHashType"),
	}
	resp, err := svc.ConfirmSignUp(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ConfirmSignUpRequest 

func (c *CognitoIdentityProvider) ConfirmSignUpRequest(input *ConfirmSignUpInput) (req *request.Request, output *ConfirmSignUpOutput)

ConfirmSignUpRequest generates a "aws/request.Request" representing the client's request for the ConfirmSignUp operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ConfirmSignUp method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ConfirmSignUpRequest method.
req, resp := client.ConfirmSignUpRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) CreateUserPool 

func (c *CognitoIdentityProvider) CreateUserPool(input *CreateUserPoolInput) (*CreateUserPoolOutput, error)

Creates a new Amazon Cognito user pool and sets the password policy for the pool.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.CreateUserPoolInput{
		PoolName: aws.String("UserPoolNameType"), // Required
		AliasAttributes: []*string{
			aws.String("AliasAttributeType"), // Required
			// More values...
		},
		AutoVerifiedAttributes: []*string{
			aws.String("VerifiedAttributeType"), // Required
			// More values...
		},
		DeviceConfiguration: &cognitoidentityprovider.DeviceConfigurationType{
			ChallengeRequiredOnNewDevice:     aws.Bool(true),
			DeviceOnlyRememberedOnUserPrompt: aws.Bool(true),
		},
		EmailConfiguration: &cognitoidentityprovider.EmailConfigurationType{
			ReplyToEmailAddress: aws.String("EmailAddressType"),
			SourceArn:           aws.String("ArnType"),
		},
		EmailVerificationMessage: aws.String("EmailVerificationMessageType"),
		EmailVerificationSubject: aws.String("EmailVerificationSubjectType"),
		LambdaConfig: &cognitoidentityprovider.LambdaConfigType{
			CreateAuthChallenge:         aws.String("ArnType"),
			CustomMessage:               aws.String("ArnType"),
			DefineAuthChallenge:         aws.String("ArnType"),
			PostAuthentication:          aws.String("ArnType"),
			PostConfirmation:            aws.String("ArnType"),
			PreAuthentication:           aws.String("ArnType"),
			PreSignUp:                   aws.String("ArnType"),
			VerifyAuthChallengeResponse: aws.String("ArnType"),
		},
		MfaConfiguration: aws.String("UserPoolMfaType"),
		Policies: &cognitoidentityprovider.UserPoolPolicyType{
			PasswordPolicy: &cognitoidentityprovider.PasswordPolicyType{
				MinimumLength:    aws.Int64(1),
				RequireLowercase: aws.Bool(true),
				RequireNumbers:   aws.Bool(true),
				RequireSymbols:   aws.Bool(true),
				RequireUppercase: aws.Bool(true),
			},
		},
		SmsAuthenticationMessage: aws.String("SmsVerificationMessageType"),
		SmsConfiguration: &cognitoidentityprovider.SmsConfigurationType{
			ExternalId:   aws.String("StringType"),
			SnsCallerArn: aws.String("ArnType"),
		},
		SmsVerificationMessage: aws.String("SmsVerificationMessageType"),
	}
	resp, err := svc.CreateUserPool(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) CreateUserPoolClient 

func (c *CognitoIdentityProvider) CreateUserPoolClient(input *CreateUserPoolClientInput) (*CreateUserPoolClientOutput, error)

Creates the user pool client.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.CreateUserPoolClientInput{
		ClientName: aws.String("ClientNameType"), // Required
		UserPoolId: aws.String("UserPoolIdType"), // Required
		ExplicitAuthFlows: []*string{
			aws.String("ExplicitAuthFlowsType"), // Required
			// More values...
		},
		GenerateSecret: aws.Bool(true),
		ReadAttributes: []*string{
			aws.String("ClientPermissionType"), // Required
			// More values...
		},
		RefreshTokenValidity: aws.Int64(1),
		WriteAttributes: []*string{
			aws.String("ClientPermissionType"), // Required
			// More values...
		},
	}
	resp, err := svc.CreateUserPoolClient(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) CreateUserPoolClientRequest 

func (c *CognitoIdentityProvider) CreateUserPoolClientRequest(input *CreateUserPoolClientInput) (req *request.Request, output *CreateUserPoolClientOutput)

CreateUserPoolClientRequest generates a "aws/request.Request" representing the client's request for the CreateUserPoolClient operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the CreateUserPoolClient method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the CreateUserPoolClientRequest method.
req, resp := client.CreateUserPoolClientRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) CreateUserPoolRequest 

func (c *CognitoIdentityProvider) CreateUserPoolRequest(input *CreateUserPoolInput) (req *request.Request, output *CreateUserPoolOutput)

CreateUserPoolRequest generates a "aws/request.Request" representing the client's request for the CreateUserPool operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the CreateUserPool method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the CreateUserPoolRequest method.
req, resp := client.CreateUserPoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) DeleteUser 

func (c *CognitoIdentityProvider) DeleteUser(input *DeleteUserInput) (*DeleteUserOutput, error)

Allows a user to delete one's self.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.DeleteUserInput{
		AccessToken: aws.String("TokenModelType"),
	}
	resp, err := svc.DeleteUser(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) DeleteUserAttributes 

func (c *CognitoIdentityProvider) DeleteUserAttributes(input *DeleteUserAttributesInput) (*DeleteUserAttributesOutput, error)

Deletes the attributes for a user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.DeleteUserAttributesInput{
		UserAttributeNames: []*string{ // Required
			aws.String("AttributeNameType"), // Required
			// More values...
		},
		AccessToken: aws.String("TokenModelType"),
	}
	resp, err := svc.DeleteUserAttributes(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) DeleteUserAttributesRequest 

func (c *CognitoIdentityProvider) DeleteUserAttributesRequest(input *DeleteUserAttributesInput) (req *request.Request, output *DeleteUserAttributesOutput)

DeleteUserAttributesRequest generates a "aws/request.Request" representing the client's request for the DeleteUserAttributes operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DeleteUserAttributes method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the DeleteUserAttributesRequest method.
req, resp := client.DeleteUserAttributesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) DeleteUserPool 

func (c *CognitoIdentityProvider) DeleteUserPool(input *DeleteUserPoolInput) (*DeleteUserPoolOutput, error)

Deletes the specified Amazon Cognito user pool.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.DeleteUserPoolInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
	}
	resp, err := svc.DeleteUserPool(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) DeleteUserPoolClient 

func (c *CognitoIdentityProvider) DeleteUserPoolClient(input *DeleteUserPoolClientInput) (*DeleteUserPoolClientOutput, error)

Allows the developer to delete the user pool client.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.DeleteUserPoolClientInput{
		ClientId:   aws.String("ClientIdType"),   // Required
		UserPoolId: aws.String("UserPoolIdType"), // Required
	}
	resp, err := svc.DeleteUserPoolClient(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) DeleteUserPoolClientRequest 

func (c *CognitoIdentityProvider) DeleteUserPoolClientRequest(input *DeleteUserPoolClientInput) (req *request.Request, output *DeleteUserPoolClientOutput)

DeleteUserPoolClientRequest generates a "aws/request.Request" representing the client's request for the DeleteUserPoolClient operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DeleteUserPoolClient method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the DeleteUserPoolClientRequest method.
req, resp := client.DeleteUserPoolClientRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) DeleteUserPoolRequest 

func (c *CognitoIdentityProvider) DeleteUserPoolRequest(input *DeleteUserPoolInput) (req *request.Request, output *DeleteUserPoolOutput)

DeleteUserPoolRequest generates a "aws/request.Request" representing the client's request for the DeleteUserPool operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DeleteUserPool method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the DeleteUserPoolRequest method.
req, resp := client.DeleteUserPoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) DeleteUserRequest 

func (c *CognitoIdentityProvider) DeleteUserRequest(input *DeleteUserInput) (req *request.Request, output *DeleteUserOutput)

DeleteUserRequest generates a "aws/request.Request" representing the client's request for the DeleteUser operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DeleteUser method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the DeleteUserRequest method.
req, resp := client.DeleteUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) DescribeUserPool 

func (c *CognitoIdentityProvider) DescribeUserPool(input *DescribeUserPoolInput) (*DescribeUserPoolOutput, error)

Returns the configuration information and metadata of the specified user pool.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.DescribeUserPoolInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
	}
	resp, err := svc.DescribeUserPool(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) DescribeUserPoolClient 

func (c *CognitoIdentityProvider) DescribeUserPoolClient(input *DescribeUserPoolClientInput) (*DescribeUserPoolClientOutput, error)

Client method for returning the configuration information and metadata of the specified user pool client.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.DescribeUserPoolClientInput{
		ClientId:   aws.String("ClientIdType"),   // Required
		UserPoolId: aws.String("UserPoolIdType"), // Required
	}
	resp, err := svc.DescribeUserPoolClient(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) DescribeUserPoolClientRequest 

func (c *CognitoIdentityProvider) DescribeUserPoolClientRequest(input *DescribeUserPoolClientInput) (req *request.Request, output *DescribeUserPoolClientOutput)

DescribeUserPoolClientRequest generates a "aws/request.Request" representing the client's request for the DescribeUserPoolClient operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DescribeUserPoolClient method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the DescribeUserPoolClientRequest method.
req, resp := client.DescribeUserPoolClientRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) DescribeUserPoolRequest 

func (c *CognitoIdentityProvider) DescribeUserPoolRequest(input *DescribeUserPoolInput) (req *request.Request, output *DescribeUserPoolOutput)

DescribeUserPoolRequest generates a "aws/request.Request" representing the client's request for the DescribeUserPool operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DescribeUserPool method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the DescribeUserPoolRequest method.
req, resp := client.DescribeUserPoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ForgetDevice 

func (c *CognitoIdentityProvider) ForgetDevice(input *ForgetDeviceInput) (*ForgetDeviceOutput, error)

Forgets the specified device.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ForgetDeviceInput{
		DeviceKey:   aws.String("DeviceKeyType"), // Required
		AccessToken: aws.String("TokenModelType"),
	}
	resp, err := svc.ForgetDevice(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ForgetDeviceRequest 

func (c *CognitoIdentityProvider) ForgetDeviceRequest(input *ForgetDeviceInput) (req *request.Request, output *ForgetDeviceOutput)

ForgetDeviceRequest generates a "aws/request.Request" representing the client's request for the ForgetDevice operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ForgetDevice method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ForgetDeviceRequest method.
req, resp := client.ForgetDeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ForgotPassword 

func (c *CognitoIdentityProvider) ForgotPassword(input *ForgotPasswordInput) (*ForgotPasswordOutput, error)

Retrieves the password for the specified client ID or username.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ForgotPasswordInput{
		ClientId:   aws.String("ClientIdType"), // Required
		Username:   aws.String("UsernameType"), // Required
		SecretHash: aws.String("SecretHashType"),
	}
	resp, err := svc.ForgotPassword(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ForgotPasswordRequest 

func (c *CognitoIdentityProvider) ForgotPasswordRequest(input *ForgotPasswordInput) (req *request.Request, output *ForgotPasswordOutput)

ForgotPasswordRequest generates a "aws/request.Request" representing the client's request for the ForgotPassword operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ForgotPassword method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ForgotPasswordRequest method.
req, resp := client.ForgotPasswordRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) GetDevice 

func (c *CognitoIdentityProvider) GetDevice(input *GetDeviceInput) (*GetDeviceOutput, error)

Gets the device.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.GetDeviceInput{
		DeviceKey:   aws.String("DeviceKeyType"), // Required
		AccessToken: aws.String("TokenModelType"),
	}
	resp, err := svc.GetDevice(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) GetDeviceRequest 

func (c *CognitoIdentityProvider) GetDeviceRequest(input *GetDeviceInput) (req *request.Request, output *GetDeviceOutput)

GetDeviceRequest generates a "aws/request.Request" representing the client's request for the GetDevice operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the GetDevice method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the GetDeviceRequest method.
req, resp := client.GetDeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) GetUser 

func (c *CognitoIdentityProvider) GetUser(input *GetUserInput) (*GetUserOutput, error)

Gets the user attributes and metadata for a user.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.GetUserInput{
		AccessToken: aws.String("TokenModelType"),
	}
	resp, err := svc.GetUser(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) GetUserAttributeVerificationCode 

func (c *CognitoIdentityProvider) GetUserAttributeVerificationCode(input *GetUserAttributeVerificationCodeInput) (*GetUserAttributeVerificationCodeOutput, error)

Gets the user attribute verification code for the specified attribute name.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.GetUserAttributeVerificationCodeInput{
		AttributeName: aws.String("AttributeNameType"), // Required
		AccessToken:   aws.String("TokenModelType"),
	}
	resp, err := svc.GetUserAttributeVerificationCode(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) GetUserAttributeVerificationCodeRequest 

func (c *CognitoIdentityProvider) GetUserAttributeVerificationCodeRequest(input *GetUserAttributeVerificationCodeInput) (req *request.Request, output *GetUserAttributeVerificationCodeOutput)

GetUserAttributeVerificationCodeRequest generates a "aws/request.Request" representing the client's request for the GetUserAttributeVerificationCode operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the GetUserAttributeVerificationCode method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the GetUserAttributeVerificationCodeRequest method.
req, resp := client.GetUserAttributeVerificationCodeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) GetUserRequest 

func (c *CognitoIdentityProvider) GetUserRequest(input *GetUserInput) (req *request.Request, output *GetUserOutput)

GetUserRequest generates a "aws/request.Request" representing the client's request for the GetUser operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the GetUser method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the GetUserRequest method.
req, resp := client.GetUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) GlobalSignOut 

func (c *CognitoIdentityProvider) GlobalSignOut(input *GlobalSignOutInput) (*GlobalSignOutOutput, error)

Signs out users from all devices.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.GlobalSignOutInput{
		AccessToken: aws.String("TokenModelType"),
	}
	resp, err := svc.GlobalSignOut(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) GlobalSignOutRequest 

func (c *CognitoIdentityProvider) GlobalSignOutRequest(input *GlobalSignOutInput) (req *request.Request, output *GlobalSignOutOutput)

GlobalSignOutRequest generates a "aws/request.Request" representing the client's request for the GlobalSignOut operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the GlobalSignOut method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the GlobalSignOutRequest method.
req, resp := client.GlobalSignOutRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) InitiateAuth 

func (c *CognitoIdentityProvider) InitiateAuth(input *InitiateAuthInput) (*InitiateAuthOutput, error)

Initiates the authentication flow.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.InitiateAuthInput{
		AuthFlow: aws.String("AuthFlowType"), // Required
		ClientId: aws.String("ClientIdType"), // Required
		AuthParameters: map[string]*string{
			"Key": aws.String("StringType"), // Required
			// More values...
		},
		ClientMetadata: map[string]*string{
			"Key": aws.String("StringType"), // Required
			// More values...
		},
	}
	resp, err := svc.InitiateAuth(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) InitiateAuthRequest 

func (c *CognitoIdentityProvider) InitiateAuthRequest(input *InitiateAuthInput) (req *request.Request, output *InitiateAuthOutput)

InitiateAuthRequest generates a "aws/request.Request" representing the client's request for the InitiateAuth operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the InitiateAuth method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the InitiateAuthRequest method.
req, resp := client.InitiateAuthRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ListDevices 

func (c *CognitoIdentityProvider) ListDevices(input *ListDevicesInput) (*ListDevicesOutput, error)

Lists the devices.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ListDevicesInput{
		AccessToken:     aws.String("TokenModelType"), // Required
		Limit:           aws.Int64(1),
		PaginationToken: aws.String("SearchPaginationTokenType"),
	}
	resp, err := svc.ListDevices(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ListDevicesRequest 

func (c *CognitoIdentityProvider) ListDevicesRequest(input *ListDevicesInput) (req *request.Request, output *ListDevicesOutput)

ListDevicesRequest generates a "aws/request.Request" representing the client's request for the ListDevices operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ListDevices method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ListDevicesRequest method.
req, resp := client.ListDevicesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ListUserPoolClients 

func (c *CognitoIdentityProvider) ListUserPoolClients(input *ListUserPoolClientsInput) (*ListUserPoolClientsOutput, error)

Lists the clients that have been created for the specified user pool.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ListUserPoolClientsInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		MaxResults: aws.Int64(1),
		NextToken:  aws.String("PaginationKey"),
	}
	resp, err := svc.ListUserPoolClients(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ListUserPoolClientsRequest 

func (c *CognitoIdentityProvider) ListUserPoolClientsRequest(input *ListUserPoolClientsInput) (req *request.Request, output *ListUserPoolClientsOutput)

ListUserPoolClientsRequest generates a "aws/request.Request" representing the client's request for the ListUserPoolClients operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ListUserPoolClients method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ListUserPoolClientsRequest method.
req, resp := client.ListUserPoolClientsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ListUserPools 

func (c *CognitoIdentityProvider) ListUserPools(input *ListUserPoolsInput) (*ListUserPoolsOutput, error)

Lists the user pools associated with an AWS account.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ListUserPoolsInput{
		MaxResults: aws.Int64(1), // Required
		NextToken:  aws.String("PaginationKeyType"),
	}
	resp, err := svc.ListUserPools(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ListUserPoolsRequest 

func (c *CognitoIdentityProvider) ListUserPoolsRequest(input *ListUserPoolsInput) (req *request.Request, output *ListUserPoolsOutput)

ListUserPoolsRequest generates a "aws/request.Request" representing the client's request for the ListUserPools operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ListUserPools method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ListUserPoolsRequest method.
req, resp := client.ListUserPoolsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ListUsers 

func (c *CognitoIdentityProvider) ListUsers(input *ListUsersInput) (*ListUsersOutput, error)

Lists the users in the Amazon Cognito user pool.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ListUsersInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		AttributesToGet: []*string{
			aws.String("AttributeNameType"), // Required
			// More values...
		},
		Filter:          aws.String("UserFilterType"),
		Limit:           aws.Int64(1),
		PaginationToken: aws.String("SearchPaginationTokenType"),
	}
	resp, err := svc.ListUsers(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ListUsersRequest 

func (c *CognitoIdentityProvider) ListUsersRequest(input *ListUsersInput) (req *request.Request, output *ListUsersOutput)

ListUsersRequest generates a "aws/request.Request" representing the client's request for the ListUsers operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ListUsers method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ListUsersRequest method.
req, resp := client.ListUsersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) ResendConfirmationCode 

func (c *CognitoIdentityProvider) ResendConfirmationCode(input *ResendConfirmationCodeInput) (*ResendConfirmationCodeOutput, error)

Resends the confirmation (for confirmation of registration) to a specific user in the user pool.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.ResendConfirmationCodeInput{
		ClientId:   aws.String("ClientIdType"), // Required
		Username:   aws.String("UsernameType"), // Required
		SecretHash: aws.String("SecretHashType"),
	}
	resp, err := svc.ResendConfirmationCode(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) ResendConfirmationCodeRequest 

func (c *CognitoIdentityProvider) ResendConfirmationCodeRequest(input *ResendConfirmationCodeInput) (req *request.Request, output *ResendConfirmationCodeOutput)

ResendConfirmationCodeRequest generates a "aws/request.Request" representing the client's request for the ResendConfirmationCode operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ResendConfirmationCode method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the ResendConfirmationCodeRequest method.
req, resp := client.ResendConfirmationCodeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) RespondToAuthChallenge 

func (c *CognitoIdentityProvider) RespondToAuthChallenge(input *RespondToAuthChallengeInput) (*RespondToAuthChallengeOutput, error)

Responds to the authentication challenge.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.RespondToAuthChallengeInput{
		ChallengeName: aws.String("ChallengeNameType"), // Required
		ClientId:      aws.String("ClientIdType"),      // Required
		ChallengeResponses: map[string]*string{
			"Key": aws.String("StringType"), // Required
			// More values...
		},
		Session: aws.String("SessionType"),
	}
	resp, err := svc.RespondToAuthChallenge(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) RespondToAuthChallengeRequest 

func (c *CognitoIdentityProvider) RespondToAuthChallengeRequest(input *RespondToAuthChallengeInput) (req *request.Request, output *RespondToAuthChallengeOutput)

RespondToAuthChallengeRequest generates a "aws/request.Request" representing the client's request for the RespondToAuthChallenge operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the RespondToAuthChallenge method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the RespondToAuthChallengeRequest method.
req, resp := client.RespondToAuthChallengeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) SetUserSettings 

func (c *CognitoIdentityProvider) SetUserSettings(input *SetUserSettingsInput) (*SetUserSettingsOutput, error)

Sets the user settings like multi-factor authentication (MFA). If MFA is to be removed for a particular attribute pass the attribute with code delivery as null. If null list is passed, all MFA options are removed.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.SetUserSettingsInput{
		AccessToken: aws.String("TokenModelType"), // Required
		MFAOptions: []*cognitoidentityprovider.MFAOptionType{ // Required
			{ // Required
				AttributeName:  aws.String("AttributeNameType"),
				DeliveryMedium: aws.String("DeliveryMediumType"),
			},
			// More values...
		},
	}
	resp, err := svc.SetUserSettings(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) SetUserSettingsRequest 

func (c *CognitoIdentityProvider) SetUserSettingsRequest(input *SetUserSettingsInput) (req *request.Request, output *SetUserSettingsOutput)

SetUserSettingsRequest generates a "aws/request.Request" representing the client's request for the SetUserSettings operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the SetUserSettings method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the SetUserSettingsRequest method.
req, resp := client.SetUserSettingsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) SignUp 

func (c *CognitoIdentityProvider) SignUp(input *SignUpInput) (*SignUpOutput, error)

Registers the user in the specified user pool and creates a user name, password, and user attributes.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.SignUpInput{
		ClientId:   aws.String("ClientIdType"), // Required
		Password:   aws.String("PasswordType"), // Required
		Username:   aws.String("UsernameType"), // Required
		SecretHash: aws.String("SecretHashType"),
		UserAttributes: []*cognitoidentityprovider.AttributeType{
			{ // Required
				Name:  aws.String("AttributeNameType"), // Required
				Value: aws.String("AttributeValueType"),
			},
			// More values...
		},
		ValidationData: []*cognitoidentityprovider.AttributeType{
			{ // Required
				Name:  aws.String("AttributeNameType"), // Required
				Value: aws.String("AttributeValueType"),
			},
			// More values...
		},
	}
	resp, err := svc.SignUp(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) SignUpRequest 

func (c *CognitoIdentityProvider) SignUpRequest(input *SignUpInput) (req *request.Request, output *SignUpOutput)

SignUpRequest generates a "aws/request.Request" representing the client's request for the SignUp operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the SignUp method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the SignUpRequest method.
req, resp := client.SignUpRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) UpdateDeviceStatus 

func (c *CognitoIdentityProvider) UpdateDeviceStatus(input *UpdateDeviceStatusInput) (*UpdateDeviceStatusOutput, error)

Updates the device status.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.UpdateDeviceStatusInput{
		AccessToken:            aws.String("TokenModelType"), // Required
		DeviceKey:              aws.String("DeviceKeyType"),  // Required
		DeviceRememberedStatus: aws.String("DeviceRememberedStatusType"),
	}
	resp, err := svc.UpdateDeviceStatus(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) UpdateDeviceStatusRequest 

func (c *CognitoIdentityProvider) UpdateDeviceStatusRequest(input *UpdateDeviceStatusInput) (req *request.Request, output *UpdateDeviceStatusOutput)

UpdateDeviceStatusRequest generates a "aws/request.Request" representing the client's request for the UpdateDeviceStatus operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the UpdateDeviceStatus method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the UpdateDeviceStatusRequest method.
req, resp := client.UpdateDeviceStatusRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) UpdateUserAttributes 

func (c *CognitoIdentityProvider) UpdateUserAttributes(input *UpdateUserAttributesInput) (*UpdateUserAttributesOutput, error)

Allows a user to update a specific attribute (one at a time).

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.UpdateUserAttributesInput{
		UserAttributes: []*cognitoidentityprovider.AttributeType{ // Required
			{ // Required
				Name:  aws.String("AttributeNameType"), // Required
				Value: aws.String("AttributeValueType"),
			},
			// More values...
		},
		AccessToken: aws.String("TokenModelType"),
	}
	resp, err := svc.UpdateUserAttributes(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) UpdateUserAttributesRequest 

func (c *CognitoIdentityProvider) UpdateUserAttributesRequest(input *UpdateUserAttributesInput) (req *request.Request, output *UpdateUserAttributesOutput)

UpdateUserAttributesRequest generates a "aws/request.Request" representing the client's request for the UpdateUserAttributes operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the UpdateUserAttributes method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the UpdateUserAttributesRequest method.
req, resp := client.UpdateUserAttributesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) UpdateUserPool 

func (c *CognitoIdentityProvider) UpdateUserPool(input *UpdateUserPoolInput) (*UpdateUserPoolOutput, error)

Updates the specified user pool with the specified attributes.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.UpdateUserPoolInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		AutoVerifiedAttributes: []*string{
			aws.String("VerifiedAttributeType"), // Required
			// More values...
		},
		DeviceConfiguration: &cognitoidentityprovider.DeviceConfigurationType{
			ChallengeRequiredOnNewDevice:     aws.Bool(true),
			DeviceOnlyRememberedOnUserPrompt: aws.Bool(true),
		},
		EmailConfiguration: &cognitoidentityprovider.EmailConfigurationType{
			ReplyToEmailAddress: aws.String("EmailAddressType"),
			SourceArn:           aws.String("ArnType"),
		},
		EmailVerificationMessage: aws.String("EmailVerificationMessageType"),
		EmailVerificationSubject: aws.String("EmailVerificationSubjectType"),
		LambdaConfig: &cognitoidentityprovider.LambdaConfigType{
			CreateAuthChallenge:         aws.String("ArnType"),
			CustomMessage:               aws.String("ArnType"),
			DefineAuthChallenge:         aws.String("ArnType"),
			PostAuthentication:          aws.String("ArnType"),
			PostConfirmation:            aws.String("ArnType"),
			PreAuthentication:           aws.String("ArnType"),
			PreSignUp:                   aws.String("ArnType"),
			VerifyAuthChallengeResponse: aws.String("ArnType"),
		},
		MfaConfiguration: aws.String("UserPoolMfaType"),
		Policies: &cognitoidentityprovider.UserPoolPolicyType{
			PasswordPolicy: &cognitoidentityprovider.PasswordPolicyType{
				MinimumLength:    aws.Int64(1),
				RequireLowercase: aws.Bool(true),
				RequireNumbers:   aws.Bool(true),
				RequireSymbols:   aws.Bool(true),
				RequireUppercase: aws.Bool(true),
			},
		},
		SmsAuthenticationMessage: aws.String("SmsVerificationMessageType"),
		SmsConfiguration: &cognitoidentityprovider.SmsConfigurationType{
			ExternalId:   aws.String("StringType"),
			SnsCallerArn: aws.String("ArnType"),
		},
		SmsVerificationMessage: aws.String("SmsVerificationMessageType"),
	}
	resp, err := svc.UpdateUserPool(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) UpdateUserPoolClient 

func (c *CognitoIdentityProvider) UpdateUserPoolClient(input *UpdateUserPoolClientInput) (*UpdateUserPoolClientOutput, error)

Allows the developer to update the specified user pool client and password policy.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.UpdateUserPoolClientInput{
		ClientId:   aws.String("ClientIdType"),   // Required
		UserPoolId: aws.String("UserPoolIdType"), // Required
		ClientName: aws.String("ClientNameType"),
		ExplicitAuthFlows: []*string{
			aws.String("ExplicitAuthFlowsType"), // Required
			// More values...
		},
		ReadAttributes: []*string{
			aws.String("ClientPermissionType"), // Required
			// More values...
		},
		RefreshTokenValidity: aws.Int64(1),
		WriteAttributes: []*string{
			aws.String("ClientPermissionType"), // Required
			// More values...
		},
	}
	resp, err := svc.UpdateUserPoolClient(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) UpdateUserPoolClientRequest 

func (c *CognitoIdentityProvider) UpdateUserPoolClientRequest(input *UpdateUserPoolClientInput) (req *request.Request, output *UpdateUserPoolClientOutput)

UpdateUserPoolClientRequest generates a "aws/request.Request" representing the client's request for the UpdateUserPoolClient operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the UpdateUserPoolClient method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the UpdateUserPoolClientRequest method.
req, resp := client.UpdateUserPoolClientRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) UpdateUserPoolRequest 

func (c *CognitoIdentityProvider) UpdateUserPoolRequest(input *UpdateUserPoolInput) (req *request.Request, output *UpdateUserPoolOutput)

UpdateUserPoolRequest generates a "aws/request.Request" representing the client's request for the UpdateUserPool operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the UpdateUserPool method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the UpdateUserPoolRequest method.
req, resp := client.UpdateUserPoolRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CognitoIdentityProvider) VerifyUserAttribute 

func (c *CognitoIdentityProvider) VerifyUserAttribute(input *VerifyUserAttributeInput) (*VerifyUserAttributeOutput, error)

Verifies the specified user attributes in the user pool.

Example 
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cognitoidentityprovider.New(sess)

	params := &cognitoidentityprovider.VerifyUserAttributeInput{
		AttributeName: aws.String("AttributeNameType"),    // Required
		Code:          aws.String("ConfirmationCodeType"), // Required
		AccessToken:   aws.String("TokenModelType"),
	}
	resp, err := svc.VerifyUserAttribute(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}

Output:

func (*CognitoIdentityProvider) VerifyUserAttributeRequest 

func (c *CognitoIdentityProvider) VerifyUserAttributeRequest(input *VerifyUserAttributeInput) (req *request.Request, output *VerifyUserAttributeOutput)

VerifyUserAttributeRequest generates a "aws/request.Request" representing the client's request for the VerifyUserAttribute operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the VerifyUserAttribute method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request. 

// Example sending a request using the VerifyUserAttributeRequest method.
req, resp := client.VerifyUserAttributeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

type ConfirmDeviceInput 

type ConfirmDeviceInput struct {

	// The access token.
	AccessToken *string `type:"string" required:"true"`

	// The device key.
	DeviceKey *string `min:"1" type:"string" required:"true"`

	// The device name.
	DeviceName *string `min:"1" type:"string"`

	// The configuration of the device secret verifier.
	DeviceSecretVerifierConfig *DeviceSecretVerifierConfigType `type:"structure"`
	// contains filtered or unexported fields
}

Confirms the device request.

func (ConfirmDeviceInput) GoString 

func (s ConfirmDeviceInput) GoString() string

GoString returns the string representation

func (ConfirmDeviceInput) String 

func (s ConfirmDeviceInput) String() string

String returns the string representation

func (*ConfirmDeviceInput) Validate 

func (s *ConfirmDeviceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ConfirmDeviceOutput 

type ConfirmDeviceOutput struct {

	// Indicates whether the user confirmation is necessary to confirm the device
	// response.
	UserConfirmationNecessary *bool `type:"boolean"`
	// contains filtered or unexported fields
}

Confirms the device response.

func (ConfirmDeviceOutput) GoString 

func (s ConfirmDeviceOutput) GoString() string

GoString returns the string representation

func (ConfirmDeviceOutput) String 

func (s ConfirmDeviceOutput) String() string

String returns the string representation

type ConfirmForgotPasswordInput 

type ConfirmForgotPasswordInput struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The confirmation code sent by a user's request to retrieve a forgotten password.
	ConfirmationCode *string `min:"1" type:"string" required:"true"`

	// The password sent by sent by a user's request to retrieve a forgotten password.
	Password *string `min:"6" type:"string" required:"true"`

	// A keyed-hash message authentication code (HMAC) calculated using the secret
	// key of a user pool client and username plus the client ID in the message.
	SecretHash *string `min:"1" type:"string"`

	// The user name of the user for whom you want to enter a code to retrieve a
	// forgotten password.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

The request representing the confirmation for a password reset.

func (ConfirmForgotPasswordInput) GoString 

func (s ConfirmForgotPasswordInput) GoString() string

GoString returns the string representation

func (ConfirmForgotPasswordInput) String 

func (s ConfirmForgotPasswordInput) String() string

String returns the string representation

func (*ConfirmForgotPasswordInput) Validate 

func (s *ConfirmForgotPasswordInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ConfirmForgotPasswordOutput 

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

The response from the server that results from a user's request to retrieve a forgotten password.

func (ConfirmForgotPasswordOutput) GoString 

func (s ConfirmForgotPasswordOutput) GoString() string

GoString returns the string representation

func (ConfirmForgotPasswordOutput) String 

func (s ConfirmForgotPasswordOutput) String() string

String returns the string representation

type ConfirmSignUpInput 

type ConfirmSignUpInput struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The confirmation code sent by a user's request to confirm registration.
	ConfirmationCode *string `min:"1" type:"string" required:"true"`

	// Boolean to be specified to force user confirmation irrespective of existing
	// alias. By default set to False. If this parameter is set to True and the
	// phone number/email used for sign up confirmation already exists as an alias
	// with a different user, the API call will migrate the alias from the previous
	// user to the newly created user being confirmed. If set to False, the API
	// will throw an AliasExistsException error.
	ForceAliasCreation *bool `type:"boolean"`

	// A keyed-hash message authentication code (HMAC) calculated using the secret
	// key of a user pool client and username plus the client ID in the message.
	SecretHash *string `min:"1" type:"string"`

	// The user name of the user whose registration you wish to confirm.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to confirm registration of a user.

func (ConfirmSignUpInput) GoString 

func (s ConfirmSignUpInput) GoString() string

GoString returns the string representation

func (ConfirmSignUpInput) String 

func (s ConfirmSignUpInput) String() string

String returns the string representation

func (*ConfirmSignUpInput) Validate 

func (s *ConfirmSignUpInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ConfirmSignUpOutput 

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

Represents the response from the server for the registration confirmation.

func (ConfirmSignUpOutput) GoString 

func (s ConfirmSignUpOutput) GoString() string

GoString returns the string representation

func (ConfirmSignUpOutput) String 

func (s ConfirmSignUpOutput) String() string

String returns the string representation

type CreateUserPoolClientInput 

type CreateUserPoolClientInput struct {

	// The client name for the user pool client you would like to create.
	ClientName *string `min:"1" type:"string" required:"true"`

	// The explicit authentication flows.
	ExplicitAuthFlows []*string `type:"list"`

	// Boolean to specify whether you want to generate a secret for the user pool
	// client being created.
	GenerateSecret *bool `type:"boolean"`

	// The read attributes.
	ReadAttributes []*string `type:"list"`

	// Refreshes the token validity.
	RefreshTokenValidity *int64 `type:"integer"`

	// The user pool ID for the user pool where you want to create a user pool client.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The write attributes.
	WriteAttributes []*string `type:"list"`
	// contains filtered or unexported fields
}

Represents the request to create a user pool client.

func (CreateUserPoolClientInput) GoString 

func (s CreateUserPoolClientInput) GoString() string

GoString returns the string representation

func (CreateUserPoolClientInput) String 

func (s CreateUserPoolClientInput) String() string

String returns the string representation

func (*CreateUserPoolClientInput) Validate 

func (s *CreateUserPoolClientInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateUserPoolClientOutput 

type CreateUserPoolClientOutput struct {

	// The user pool client that was just created.
	UserPoolClient *UserPoolClientType `type:"structure"`
	// contains filtered or unexported fields
}

Represents the response from the server to create a user pool client.

func (CreateUserPoolClientOutput) GoString 

func (s CreateUserPoolClientOutput) GoString() string

GoString returns the string representation

func (CreateUserPoolClientOutput) String 

func (s CreateUserPoolClientOutput) String() string

String returns the string representation

type CreateUserPoolInput 

type CreateUserPoolInput struct {

	// Attributes supported as an alias for this user pool. Possible values: phone_number,
	// email, or preferred_username.
	AliasAttributes []*string `type:"list"`

	// The attributes to be auto-verified. Possible values: email, phone_number.
	AutoVerifiedAttributes []*string `type:"list"`

	// The device configuration.
	DeviceConfiguration *DeviceConfigurationType `type:"structure"`

	// The email configuration.
	EmailConfiguration *EmailConfigurationType `type:"structure"`

	// A string representing the email verification message.
	EmailVerificationMessage *string `min:"6" type:"string"`

	// A string representing the email verification subject.
	EmailVerificationSubject *string `min:"1" type:"string"`

	// The Lambda trigger configuration information for the new user pool.
	LambdaConfig *LambdaConfigType `type:"structure"`

	// Specifies MFA configuration details.
	MfaConfiguration *string `type:"string" enum:"UserPoolMfaType"`

	// The policies associated with the new user pool.
	Policies *UserPoolPolicyType `type:"structure"`

	// A string used to name the user pool.
	PoolName *string `min:"1" type:"string" required:"true"`

	// A string representing the SMS authentication message.
	SmsAuthenticationMessage *string `min:"6" type:"string"`

	// The SMS configuration.
	SmsConfiguration *SmsConfigurationType `type:"structure"`

	// A string representing the SMS verification message.
	SmsVerificationMessage *string `min:"6" type:"string"`
	// contains filtered or unexported fields
}

Represents the request to create a user pool.

func (CreateUserPoolInput) GoString 

func (s CreateUserPoolInput) GoString() string

GoString returns the string representation

func (CreateUserPoolInput) String 

func (s CreateUserPoolInput) String() string

String returns the string representation

func (*CreateUserPoolInput) Validate 

func (s *CreateUserPoolInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateUserPoolOutput 

type CreateUserPoolOutput struct {

	// A container for the user pool details.
	UserPool *UserPoolType `type:"structure"`
	// contains filtered or unexported fields
}

Represents the response from the server for the request to create a user pool.

func (CreateUserPoolOutput) GoString 

func (s CreateUserPoolOutput) GoString() string

GoString returns the string representation

func (CreateUserPoolOutput) String 

func (s CreateUserPoolOutput) String() string

String returns the string representation

type DeleteUserAttributesInput 

type DeleteUserAttributesInput struct {

	// The access token used in the request to delete user attributes.
	AccessToken *string `type:"string"`

	// An array of strings representing the user attribute names you wish to delete.
	UserAttributeNames []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to delete user attributes.

func (DeleteUserAttributesInput) GoString 

func (s DeleteUserAttributesInput) GoString() string

GoString returns the string representation

func (DeleteUserAttributesInput) String 

func (s DeleteUserAttributesInput) String() string

String returns the string representation

func (*DeleteUserAttributesInput) Validate 

func (s *DeleteUserAttributesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteUserAttributesOutput 

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

Represents the response from the server to delete user attributes.

func (DeleteUserAttributesOutput) GoString 

func (s DeleteUserAttributesOutput) GoString() string

GoString returns the string representation

func (DeleteUserAttributesOutput) String 

func (s DeleteUserAttributesOutput) String() string

String returns the string representation

type DeleteUserInput 

type DeleteUserInput struct {

	// The access token from a request to delete a user.
	AccessToken *string `type:"string"`
	// contains filtered or unexported fields
}

Represents the request to delete a user.

func (DeleteUserInput) GoString 

func (s DeleteUserInput) GoString() string

GoString returns the string representation

func (DeleteUserInput) String 

func (s DeleteUserInput) String() string

String returns the string representation

type DeleteUserOutput 

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

func (DeleteUserOutput) GoString 

func (s DeleteUserOutput) GoString() string

GoString returns the string representation

func (DeleteUserOutput) String 

func (s DeleteUserOutput) String() string

String returns the string representation

type DeleteUserPoolClientInput 

type DeleteUserPoolClientInput struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The user pool ID for the user pool where you want to delete the client.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to delete a user pool client.

func (DeleteUserPoolClientInput) GoString 

func (s DeleteUserPoolClientInput) GoString() string

GoString returns the string representation

func (DeleteUserPoolClientInput) String 

func (s DeleteUserPoolClientInput) String() string

String returns the string representation

func (*DeleteUserPoolClientInput) Validate 

func (s *DeleteUserPoolClientInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteUserPoolClientOutput 

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

func (DeleteUserPoolClientOutput) GoString 

func (s DeleteUserPoolClientOutput) GoString() string

GoString returns the string representation

func (DeleteUserPoolClientOutput) String 

func (s DeleteUserPoolClientOutput) String() string

String returns the string representation

type DeleteUserPoolInput 

type DeleteUserPoolInput struct {

	// The user pool ID for the user pool you want to delete.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to delete a user pool.

func (DeleteUserPoolInput) GoString 

func (s DeleteUserPoolInput) GoString() string

GoString returns the string representation

func (DeleteUserPoolInput) String 

func (s DeleteUserPoolInput) String() string

String returns the string representation

func (*DeleteUserPoolInput) Validate 

func (s *DeleteUserPoolInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteUserPoolOutput 

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

func (DeleteUserPoolOutput) GoString 

func (s DeleteUserPoolOutput) GoString() string

GoString returns the string representation

func (DeleteUserPoolOutput) String 

func (s DeleteUserPoolOutput) String() string

String returns the string representation

type DescribeUserPoolClientInput 

type DescribeUserPoolClientInput struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The user pool ID for the user pool you want to describe.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to describe a user pool client.

func (DescribeUserPoolClientInput) GoString 

func (s DescribeUserPoolClientInput) GoString() string

GoString returns the string representation

func (DescribeUserPoolClientInput) String 

func (s DescribeUserPoolClientInput) String() string

String returns the string representation

func (*DescribeUserPoolClientInput) Validate 

func (s *DescribeUserPoolClientInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeUserPoolClientOutput 

type DescribeUserPoolClientOutput struct {

	// The user pool client from a server response to describe the user pool client.
	UserPoolClient *UserPoolClientType `type:"structure"`
	// contains filtered or unexported fields
}

Represents the response from the server from a request to describe the user pool client.

func (DescribeUserPoolClientOutput) GoString 

func (s DescribeUserPoolClientOutput) GoString() string

GoString returns the string representation

func (DescribeUserPoolClientOutput) String 

func (s DescribeUserPoolClientOutput) String() string

String returns the string representation

type DescribeUserPoolInput 

type DescribeUserPoolInput struct {

	// The user pool ID for the user pool you want to describe.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to describe the user pool.

func (DescribeUserPoolInput) GoString 

func (s DescribeUserPoolInput) GoString() string

GoString returns the string representation

func (DescribeUserPoolInput) String 

func (s DescribeUserPoolInput) String() string

String returns the string representation

func (*DescribeUserPoolInput) Validate 

func (s *DescribeUserPoolInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeUserPoolOutput 

type DescribeUserPoolOutput struct {

	// The container of metadata returned by the server to describe the pool.
	UserPool *UserPoolType `type:"structure"`
	// contains filtered or unexported fields
}

Represents the response to describe the user pool.

func (DescribeUserPoolOutput) GoString 

func (s DescribeUserPoolOutput) GoString() string

GoString returns the string representation

func (DescribeUserPoolOutput) String 

func (s DescribeUserPoolOutput) String() string

String returns the string representation

type DeviceConfigurationType 

type DeviceConfigurationType struct {

	// Indicates whether a challenge is required on a new device. Only applicable
	// to a new device.
	ChallengeRequiredOnNewDevice *bool `type:"boolean"`

	// If true, a device is only remembered on user prompt.
	DeviceOnlyRememberedOnUserPrompt *bool `type:"boolean"`
	// contains filtered or unexported fields
}

The type of configuration for the user pool's device tracking.

func (DeviceConfigurationType) GoString 

func (s DeviceConfigurationType) GoString() string

GoString returns the string representation

func (DeviceConfigurationType) String 

func (s DeviceConfigurationType) String() string

String returns the string representation

type DeviceSecretVerifierConfigType 

type DeviceSecretVerifierConfigType struct {

	// The password verifier.
	PasswordVerifier *string `type:"string"`

	// The salt.
	Salt *string `type:"string"`
	// contains filtered or unexported fields
}

The device verifier against which it will be authenticated.

func (DeviceSecretVerifierConfigType) GoString 

func (s DeviceSecretVerifierConfigType) GoString() string

GoString returns the string representation

func (DeviceSecretVerifierConfigType) String 

func (s DeviceSecretVerifierConfigType) String() string

String returns the string representation

type DeviceType 

type DeviceType struct {

	// The device attributes.
	DeviceAttributes []*AttributeType `type:"list"`

	// The creation date of the device.
	DeviceCreateDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The device key.
	DeviceKey *string `min:"1" type:"string"`

	// The date in which the device was last authenticated.
	DeviceLastAuthenticatedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The last modified date of the device.
	DeviceLastModifiedDate *time.Time `type:"timestamp" timestampFormat:"unix"`
	// contains filtered or unexported fields
}

The device type.

func (DeviceType) GoString 

func (s DeviceType) GoString() string

GoString returns the string representation

func (DeviceType) String 

func (s DeviceType) String() string

String returns the string representation

type EmailConfigurationType 

type EmailConfigurationType struct {

	// The REPLY-TO email address.
	ReplyToEmailAddress *string `type:"string"`

	// The Amazon Resource Name (ARN) of the email source.
	SourceArn *string `min:"20" type:"string"`
	// contains filtered or unexported fields
}

The email configuration type.

func (EmailConfigurationType) GoString 

func (s EmailConfigurationType) GoString() string

GoString returns the string representation

func (EmailConfigurationType) String 

func (s EmailConfigurationType) String() string

String returns the string representation

func (*EmailConfigurationType) Validate 

func (s *EmailConfigurationType) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ForgetDeviceInput 

type ForgetDeviceInput struct {

	// The access token for the forgotten device request.
	AccessToken *string `type:"string"`

	// The device key.
	DeviceKey *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to forget the device.

func (ForgetDeviceInput) GoString 

func (s ForgetDeviceInput) GoString() string

GoString returns the string representation

func (ForgetDeviceInput) String 

func (s ForgetDeviceInput) String() string

String returns the string representation

func (*ForgetDeviceInput) Validate 

func (s *ForgetDeviceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ForgetDeviceOutput 

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

func (ForgetDeviceOutput) GoString 

func (s ForgetDeviceOutput) GoString() string

GoString returns the string representation

func (ForgetDeviceOutput) String 

func (s ForgetDeviceOutput) String() string

String returns the string representation

type ForgotPasswordInput 

type ForgotPasswordInput struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string" required:"true"`

	// A keyed-hash message authentication code (HMAC) calculated using the secret
	// key of a user pool client and username plus the client ID in the message.
	SecretHash *string `min:"1" type:"string"`

	// The user name of the user for whom you want to enter a code to retrieve a
	// forgotten password.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to reset a user's password.

func (ForgotPasswordInput) GoString 

func (s ForgotPasswordInput) GoString() string

GoString returns the string representation

func (ForgotPasswordInput) String 

func (s ForgotPasswordInput) String() string

String returns the string representation

func (*ForgotPasswordInput) Validate 

func (s *ForgotPasswordInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ForgotPasswordOutput 

type ForgotPasswordOutput struct {

	// The type of code delivery details being returned from the server.
	CodeDeliveryDetails *CodeDeliveryDetailsType `type:"structure"`
	// contains filtered or unexported fields
}

Respresents the response from the server regarding the request to reset a password.

func (ForgotPasswordOutput) GoString 

func (s ForgotPasswordOutput) GoString() string

GoString returns the string representation

func (ForgotPasswordOutput) String 

func (s ForgotPasswordOutput) String() string

String returns the string representation

type GetDeviceInput 

type GetDeviceInput struct {

	// The access token.
	AccessToken *string `type:"string"`

	// The device key.
	DeviceKey *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to get the device.

func (GetDeviceInput) GoString 

func (s GetDeviceInput) GoString() string

GoString returns the string representation

func (GetDeviceInput) String 

func (s GetDeviceInput) String() string

String returns the string representation

func (*GetDeviceInput) Validate 

func (s *GetDeviceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetDeviceOutput 

type GetDeviceOutput struct {

	// The device.
	Device *DeviceType `type:"structure" required:"true"`
	// contains filtered or unexported fields
}

Gets the device response.

func (GetDeviceOutput) GoString 

func (s GetDeviceOutput) GoString() string

GoString returns the string representation

func (GetDeviceOutput) String 

func (s GetDeviceOutput) String() string

String returns the string representation

type GetUserAttributeVerificationCodeInput 

type GetUserAttributeVerificationCodeInput struct {

	// The access token returned by the server response to get the user attribute
	// verification code.
	AccessToken *string `type:"string"`

	// The attribute name returned by the server response to get the user attribute
	// verification code.
	AttributeName *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to get user attribute verification.

func (GetUserAttributeVerificationCodeInput) GoString 

func (s GetUserAttributeVerificationCodeInput) GoString() string

GoString returns the string representation

func (GetUserAttributeVerificationCodeInput) String 

func (s GetUserAttributeVerificationCodeInput) String() string

String returns the string representation

func (*GetUserAttributeVerificationCodeInput) Validate 

func (s *GetUserAttributeVerificationCodeInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetUserAttributeVerificationCodeOutput 

type GetUserAttributeVerificationCodeOutput struct {

	// The code delivery details returned by the server response to get the user
	// attribute verification code.
	CodeDeliveryDetails *CodeDeliveryDetailsType `type:"structure"`
	// contains filtered or unexported fields
}

The verification code response returned by the server response to get the user attribute verification code.

func (GetUserAttributeVerificationCodeOutput) GoString 

func (s GetUserAttributeVerificationCodeOutput) GoString() string

GoString returns the string representation

func (GetUserAttributeVerificationCodeOutput) String 

func (s GetUserAttributeVerificationCodeOutput) String() string

String returns the string representation

type GetUserInput 

type GetUserInput struct {

	// The access token returned by the server response to get information about
	// the user.
	AccessToken *string `type:"string"`
	// contains filtered or unexported fields
}

Represents the request to get information about the user.

func (GetUserInput) GoString 

func (s GetUserInput) GoString() string

GoString returns the string representation

func (GetUserInput) String 

func (s GetUserInput) String() string

String returns the string representation

type GetUserOutput 

type GetUserOutput struct {

	// Specifies the options for MFA (e.g., email or phone number).
	MFAOptions []*MFAOptionType `type:"list"`

	// An array of name-value pairs representing user attributes.
	UserAttributes []*AttributeType `type:"list" required:"true"`

	// The user name of the user you wish to retrieve from the get user request.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the response from the server from the request to get information about the user.

func (GetUserOutput) GoString 

func (s GetUserOutput) GoString() string

GoString returns the string representation

func (GetUserOutput) String 

func (s GetUserOutput) String() string

String returns the string representation

type GlobalSignOutInput 

type GlobalSignOutInput struct {

	// The access token.
	AccessToken *string `type:"string"`
	// contains filtered or unexported fields
}

Represents the request to sign out all devices.

func (GlobalSignOutInput) GoString 

func (s GlobalSignOutInput) GoString() string

GoString returns the string representation

func (GlobalSignOutInput) String 

func (s GlobalSignOutInput) String() string

String returns the string representation

type GlobalSignOutOutput 

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

The response to the request to sign out all devices.

func (GlobalSignOutOutput) GoString 

func (s GlobalSignOutOutput) GoString() string

GoString returns the string representation

func (GlobalSignOutOutput) String 

func (s GlobalSignOutOutput) String() string

String returns the string representation

type InitiateAuthInput 

type InitiateAuthInput struct {

	// The authentication flow.
	AuthFlow *string `type:"string" required:"true" enum:"AuthFlowType"`

	// The authentication parameters.
	AuthParameters map[string]*string `type:"map"`

	// The client ID.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The client app's metadata.
	ClientMetadata map[string]*string `type:"map"`
	// contains filtered or unexported fields
}

Initiates the authentication request.

func (InitiateAuthInput) GoString 

func (s InitiateAuthInput) GoString() string

GoString returns the string representation

func (InitiateAuthInput) String 

func (s InitiateAuthInput) String() string

String returns the string representation

func (*InitiateAuthInput) Validate 

func (s *InitiateAuthInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type InitiateAuthOutput 

type InitiateAuthOutput struct {

	// The result type of the authentication result.
	AuthenticationResult *AuthenticationResultType `type:"structure"`

	// The name of the challenge.
	ChallengeName *string `type:"string" enum:"ChallengeNameType"`

	// The challenge parameters.
	ChallengeParameters map[string]*string `type:"map"`

	// The session.
	Session *string `min:"20" type:"string"`
	// contains filtered or unexported fields
}

Initiates the authentication response.

func (InitiateAuthOutput) GoString 

func (s InitiateAuthOutput) GoString() string

GoString returns the string representation

func (InitiateAuthOutput) String 

func (s InitiateAuthOutput) String() string

String returns the string representation

type LambdaConfigType 

type LambdaConfigType struct {

	// Creates an authentication challenge.
	CreateAuthChallenge *string `min:"20" type:"string"`

	// A custom Message AWS Lambda trigger.
	CustomMessage *string `min:"20" type:"string"`

	// Defines the authentication challenge.
	DefineAuthChallenge *string `min:"20" type:"string"`

	// A post-authentication AWS Lambda trigger.
	PostAuthentication *string `min:"20" type:"string"`

	// A post-confirmation AWS Lambda trigger.
	PostConfirmation *string `min:"20" type:"string"`

	// A pre-authentication AWS Lambda trigger.
	PreAuthentication *string `min:"20" type:"string"`

	// A pre-registration AWS Lambda trigger.
	PreSignUp *string `min:"20" type:"string"`

	// Verifies the authentication challenge response.
	VerifyAuthChallengeResponse *string `min:"20" type:"string"`
	// contains filtered or unexported fields
}

Specifies the type of configuration for AWS Lambda triggers.

func (LambdaConfigType) GoString 

func (s LambdaConfigType) GoString() string

GoString returns the string representation

func (LambdaConfigType) String 

func (s LambdaConfigType) String() string

String returns the string representation

func (*LambdaConfigType) Validate 

func (s *LambdaConfigType) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListDevicesInput 

type ListDevicesInput struct {

	// The access tokens for the request to list devices.
	AccessToken *string `type:"string" required:"true"`

	// The limit of the device request.
	Limit *int64 `type:"integer"`

	// The pagination token for the list request.
	PaginationToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

Represents the request to list the devices.

func (ListDevicesInput) GoString 

func (s ListDevicesInput) GoString() string

GoString returns the string representation

func (ListDevicesInput) String 

func (s ListDevicesInput) String() string

String returns the string representation

func (*ListDevicesInput) Validate 

func (s *ListDevicesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListDevicesOutput 

type ListDevicesOutput struct {

	// The devices returned in the list devices response.
	Devices []*DeviceType `type:"list"`

	// The pagination token for the list device response.
	PaginationToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

Represents the response to list devices.

func (ListDevicesOutput) GoString 

func (s ListDevicesOutput) GoString() string

GoString returns the string representation

func (ListDevicesOutput) String 

func (s ListDevicesOutput) String() string

String returns the string representation

type ListUserPoolClientsInput 

type ListUserPoolClientsInput struct {

	// The maximum number of results you want the request to return when listing
	// the user pool clients.
	MaxResults *int64 `min:"1" type:"integer"`

	// An identifier that was returned from the previous call to this operation,
	// which can be used to return the next set of items in the list.
	NextToken *string `min:"1" type:"string"`

	// The user pool ID for the user pool where you want to list user pool clients.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to list the user pool clients.

func (ListUserPoolClientsInput) GoString 

func (s ListUserPoolClientsInput) GoString() string

GoString returns the string representation

func (ListUserPoolClientsInput) String 

func (s ListUserPoolClientsInput) String() string

String returns the string representation

func (*ListUserPoolClientsInput) Validate 

func (s *ListUserPoolClientsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListUserPoolClientsOutput 

type ListUserPoolClientsOutput struct {

	// An identifier that was returned from the previous call to this operation,
	// which can be used to return the next set of items in the list.
	NextToken *string `min:"1" type:"string"`

	// The user pool clients in the response that lists user pool clients.
	UserPoolClients []*UserPoolClientDescription `type:"list"`
	// contains filtered or unexported fields
}

Represents the response from the server that lists user pool clients.

func (ListUserPoolClientsOutput) GoString 

func (s ListUserPoolClientsOutput) GoString() string

GoString returns the string representation

func (ListUserPoolClientsOutput) String 

func (s ListUserPoolClientsOutput) String() string

String returns the string representation

type ListUserPoolsInput 

type ListUserPoolsInput struct {

	// The maximum number of results you want the request to return when listing
	// the user pools.
	MaxResults *int64 `min:"1" type:"integer" required:"true"`

	// An identifier that was returned from the previous call to this operation,
	// which can be used to return the next set of items in the list.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

Represents the request to list user pools.

func (ListUserPoolsInput) GoString 

func (s ListUserPoolsInput) GoString() string

GoString returns the string representation

func (ListUserPoolsInput) String 

func (s ListUserPoolsInput) String() string

String returns the string representation

func (*ListUserPoolsInput) Validate 

func (s *ListUserPoolsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListUserPoolsOutput 

type ListUserPoolsOutput struct {

	// An identifier that was returned from the previous call to this operation,
	// which can be used to return the next set of items in the list.
	NextToken *string `min:"1" type:"string"`

	// The user pools from the response to list users.
	UserPools []*UserPoolDescriptionType `type:"list"`
	// contains filtered or unexported fields
}

Represents the response to list user pools.

func (ListUserPoolsOutput) GoString 

func (s ListUserPoolsOutput) GoString() string

GoString returns the string representation

func (ListUserPoolsOutput) String 

func (s ListUserPoolsOutput) String() string

String returns the string representation

type ListUsersInput 

type ListUsersInput struct {

	// The attributes to get from the request to list users.
	AttributesToGet []*string `type:"list"`

	// The filter for the list users request.
	Filter *string `type:"string"`

	// The limit of the request to list users.
	Limit *int64 `type:"integer"`

	// An identifier that was returned from the previous call to this operation,
	// which can be used to return the next set of items in the list.
	PaginationToken *string `min:"1" type:"string"`

	// The user pool ID for which you want to list users.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to list users.

func (ListUsersInput) GoString 

func (s ListUsersInput) GoString() string

GoString returns the string representation

func (ListUsersInput) String 

func (s ListUsersInput) String() string

String returns the string representation

func (*ListUsersInput) Validate 

func (s *ListUsersInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListUsersOutput 

type ListUsersOutput struct {

	// An identifier that was returned from the previous call to this operation,
	// which can be used to return the next set of items in the list.
	PaginationToken *string `min:"1" type:"string"`

	// The users returned in the request to list users.
	Users []*UserType `type:"list"`
	// contains filtered or unexported fields
}

The response from the request to list users.

func (ListUsersOutput) GoString 

func (s ListUsersOutput) GoString() string

GoString returns the string representation

func (ListUsersOutput) String 

func (s ListUsersOutput) String() string

String returns the string representation

type MFAOptionType 

type MFAOptionType struct {

	// The attribute name of the MFA option type.
	AttributeName *string `min:"1" type:"string"`

	// The delivery medium (email message or SMS message) to send the MFA code.
	DeliveryMedium *string `type:"string" enum:"DeliveryMediumType"`
	// contains filtered or unexported fields
}

Specifies the different settings for multi-factor authentication (MFA).

func (MFAOptionType) GoString 

func (s MFAOptionType) GoString() string

GoString returns the string representation

func (MFAOptionType) String 

func (s MFAOptionType) String() string

String returns the string representation

func (*MFAOptionType) Validate 

func (s *MFAOptionType) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type NewDeviceMetadataType 

type NewDeviceMetadataType struct {

	// The device group key.
	DeviceGroupKey *string `type:"string"`

	// The device key.
	DeviceKey *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

The new device metadata type.

func (NewDeviceMetadataType) GoString 

func (s NewDeviceMetadataType) GoString() string

GoString returns the string representation

func (NewDeviceMetadataType) String 

func (s NewDeviceMetadataType) String() string

String returns the string representation

type NumberAttributeConstraintsType 

type NumberAttributeConstraintsType struct {

	// The maximum value of an attribute that is of the number data type.
	MaxValue *string `type:"string"`

	// The minimum value of an attribute that is of the number data type.
	MinValue *string `type:"string"`
	// contains filtered or unexported fields
}

The minimum and maximum value of an attribute that is of the number data type.

func (NumberAttributeConstraintsType) GoString 

func (s NumberAttributeConstraintsType) GoString() string

GoString returns the string representation

func (NumberAttributeConstraintsType) String 

func (s NumberAttributeConstraintsType) String() string

String returns the string representation

type PasswordPolicyType 

type PasswordPolicyType struct {

	// The minimum length of the password policy that you have set. Cannot be less
	// than 6.
	MinimumLength *int64 `min:"6" type:"integer"`

	// In the password policy that you have set, refers to whether you have required
	// users to use at least one lowercase letter in their password.
	RequireLowercase *bool `type:"boolean"`

	// In the password policy that you have set, refers to whether you have required
	// users to use at least one number in their password.
	RequireNumbers *bool `type:"boolean"`

	// In the password policy that you have set, refers to whether you have required
	// users to use at least one symbol in their password.
	RequireSymbols *bool `type:"boolean"`

	// In the password policy that you have set, refers to whether you have required
	// users to use at least one uppercase letter in their password.
	RequireUppercase *bool `type:"boolean"`
	// contains filtered or unexported fields
}

The password policy type.

func (PasswordPolicyType) GoString 

func (s PasswordPolicyType) GoString() string

GoString returns the string representation

func (PasswordPolicyType) String 

func (s PasswordPolicyType) String() string

String returns the string representation

func (*PasswordPolicyType) Validate 

func (s *PasswordPolicyType) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ResendConfirmationCodeInput 

type ResendConfirmationCodeInput struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string" required:"true"`

	// A keyed-hash message authentication code (HMAC) calculated using the secret
	// key of a user pool client and username plus the client ID in the message.
	SecretHash *string `min:"1" type:"string"`

	// The user name of the user to whom you wish to resend a confirmation code.
	Username *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to resend the confirmation code.

func (ResendConfirmationCodeInput) GoString 

func (s ResendConfirmationCodeInput) GoString() string

GoString returns the string representation

func (ResendConfirmationCodeInput) String 

func (s ResendConfirmationCodeInput) String() string

String returns the string representation

func (*ResendConfirmationCodeInput) Validate 

func (s *ResendConfirmationCodeInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ResendConfirmationCodeOutput 

type ResendConfirmationCodeOutput struct {

	// The type of code delivery details being returned from the server.
	CodeDeliveryDetails *CodeDeliveryDetailsType `type:"structure"`
	// contains filtered or unexported fields
}

The response from the server when the Amazon Cognito service makes the request to resend a confirmation code.

func (ResendConfirmationCodeOutput) GoString 

func (s ResendConfirmationCodeOutput) GoString() string

GoString returns the string representation

func (ResendConfirmationCodeOutput) String 

func (s ResendConfirmationCodeOutput) String() string

String returns the string representation

type RespondToAuthChallengeInput 

type RespondToAuthChallengeInput struct {

	// The name of the challenge.
	ChallengeName *string `type:"string" required:"true" enum:"ChallengeNameType"`

	// The responses to the authentication challenge.
	ChallengeResponses map[string]*string `type:"map"`

	// The client ID.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The session.
	Session *string `min:"20" type:"string"`
	// contains filtered or unexported fields
}

The request to respond to an authentication challenge.

func (RespondToAuthChallengeInput) GoString 

func (s RespondToAuthChallengeInput) GoString() string

GoString returns the string representation

func (RespondToAuthChallengeInput) String 

func (s RespondToAuthChallengeInput) String() string

String returns the string representation

func (*RespondToAuthChallengeInput) Validate 

func (s *RespondToAuthChallengeInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type RespondToAuthChallengeOutput 

type RespondToAuthChallengeOutput struct {

	// The result type of the authentication result.
	AuthenticationResult *AuthenticationResultType `type:"structure"`

	// The challenge name.
	ChallengeName *string `type:"string" enum:"ChallengeNameType"`

	// The challenge parameters.
	ChallengeParameters map[string]*string `type:"map"`

	// The session.
	Session *string `min:"20" type:"string"`
	// contains filtered or unexported fields
}

The response to respond to the authentication challenge.

func (RespondToAuthChallengeOutput) GoString 

func (s RespondToAuthChallengeOutput) GoString() string

GoString returns the string representation

func (RespondToAuthChallengeOutput) String 

func (s RespondToAuthChallengeOutput) String() string

String returns the string representation

type SchemaAttributeType 

type SchemaAttributeType struct {

	// The attribute data type.
	AttributeDataType *string `type:"string" enum:"AttributeDataType"`

	// Specifies whether the attribute type is developer only.
	DeveloperOnlyAttribute *bool `type:"boolean"`

	// Specifies whether the attribute can be changed once it has been created.
	Mutable *bool `type:"boolean"`

	// A schema attribute of the name type.
	Name *string `min:"1" type:"string"`

	// Specifies the constraints for an attribute of the number type.
	NumberAttributeConstraints *NumberAttributeConstraintsType `type:"structure"`

	// Specifies whether a user pool attribute is required. If the attribute is
	// required and the user does not provide a value, registration or sign-in will
	// fail.
	Required *bool `type:"boolean"`

	// Specifies the constraints for an attribute of the string type.
	StringAttributeConstraints *StringAttributeConstraintsType `type:"structure"`
	// contains filtered or unexported fields
}

Contains information about the schema attribute.

func (SchemaAttributeType) GoString 

func (s SchemaAttributeType) GoString() string

GoString returns the string representation

func (SchemaAttributeType) String 

func (s SchemaAttributeType) String() string

String returns the string representation

func (*SchemaAttributeType) Validate 

func (s *SchemaAttributeType) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type SetUserSettingsInput 

type SetUserSettingsInput struct {

	// The access token for the set user settings request.
	AccessToken *string `type:"string" required:"true"`

	// Specifies the options for MFA (e.g., email or phone number).
	MFAOptions []*MFAOptionType `type:"list" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to set user settings.

func (SetUserSettingsInput) GoString 

func (s SetUserSettingsInput) GoString() string

GoString returns the string representation

func (SetUserSettingsInput) String 

func (s SetUserSettingsInput) String() string

String returns the string representation

func (*SetUserSettingsInput) Validate 

func (s *SetUserSettingsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type SetUserSettingsOutput 

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

The response from the server for a set user settings request.

func (SetUserSettingsOutput) GoString 

func (s SetUserSettingsOutput) GoString() string

GoString returns the string representation

func (SetUserSettingsOutput) String 

func (s SetUserSettingsOutput) String() string

String returns the string representation

type SignUpInput 

type SignUpInput struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The password of the user you wish to register.
	Password *string `min:"6" type:"string" required:"true"`

	// A keyed-hash message authentication code (HMAC) calculated using the secret
	// key of a user pool client and username plus the client ID in the message.
	SecretHash *string `min:"1" type:"string"`

	// An array of name-value pairs representing user attributes.
	UserAttributes []*AttributeType `type:"list"`

	// The user name of the user you wish to register.
	Username *string `min:"1" type:"string" required:"true"`

	// The validation data in the request to register a user.
	ValidationData []*AttributeType `type:"list"`
	// contains filtered or unexported fields
}

Represents the request to register a user.

func (SignUpInput) GoString 

func (s SignUpInput) GoString() string

GoString returns the string representation

func (SignUpInput) String 

func (s SignUpInput) String() string

String returns the string representation

func (*SignUpInput) Validate 

func (s *SignUpInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type SignUpOutput 

type SignUpOutput struct {

	// The type of code delivery details being returned from the server.
	CodeDeliveryDetails *CodeDeliveryDetailsType `type:"structure"`

	// A response from the server indicating that a user registration has been confirmed.
	UserConfirmed *bool `type:"boolean"`
	// contains filtered or unexported fields
}

The response from the server for a registration request.

func (SignUpOutput) GoString 

func (s SignUpOutput) GoString() string

GoString returns the string representation

func (SignUpOutput) String 

func (s SignUpOutput) String() string

String returns the string representation

type SmsConfigurationType 

type SmsConfigurationType struct {

	// The external ID.
	ExternalId *string `type:"string"`

	// The Amazon Resource Name (ARN) of the Amazon Simple Notification Service
	// (SNS) caller.
	SnsCallerArn *string `min:"20" type:"string"`
	// contains filtered or unexported fields
}

The SMS configuratoin type.

func (SmsConfigurationType) GoString 

func (s SmsConfigurationType) GoString() string

GoString returns the string representation

func (SmsConfigurationType) String 

func (s SmsConfigurationType) String() string

String returns the string representation

func (*SmsConfigurationType) Validate 

func (s *SmsConfigurationType) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type StringAttributeConstraintsType 

type StringAttributeConstraintsType struct {

	// The maximum length of an attribute value of the string type.
	MaxLength *string `type:"string"`

	// The minimum length of an attribute value of the string type.
	MinLength *string `type:"string"`
	// contains filtered or unexported fields
}

The type of constraints associated with an attribute of the string type.

func (StringAttributeConstraintsType) GoString 

func (s StringAttributeConstraintsType) GoString() string

GoString returns the string representation

func (StringAttributeConstraintsType) String 

func (s StringAttributeConstraintsType) String() string

String returns the string representation

type UpdateDeviceStatusInput 

type UpdateDeviceStatusInput struct {

	// The access token.
	AccessToken *string `type:"string" required:"true"`

	// The device key.
	DeviceKey *string `min:"1" type:"string" required:"true"`

	// The status of whether a device is remembered.
	DeviceRememberedStatus *string `type:"string" enum:"DeviceRememberedStatusType"`
	// contains filtered or unexported fields
}

Represents the request to update the device status.

func (UpdateDeviceStatusInput) GoString 

func (s UpdateDeviceStatusInput) GoString() string

GoString returns the string representation

func (UpdateDeviceStatusInput) String 

func (s UpdateDeviceStatusInput) String() string

String returns the string representation

func (*UpdateDeviceStatusInput) Validate 

func (s *UpdateDeviceStatusInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UpdateDeviceStatusOutput 

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

The response to the request to update the device status.

func (UpdateDeviceStatusOutput) GoString 

func (s UpdateDeviceStatusOutput) GoString() string

GoString returns the string representation

func (UpdateDeviceStatusOutput) String 

func (s UpdateDeviceStatusOutput) String() string

String returns the string representation

type UpdateUserAttributesInput 

type UpdateUserAttributesInput struct {

	// The access token for the request to update user attributes.
	AccessToken *string `type:"string"`

	// An array of name-value pairs representing user attributes.
	UserAttributes []*AttributeType `type:"list" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to update user attributes.

func (UpdateUserAttributesInput) GoString 

func (s UpdateUserAttributesInput) GoString() string

GoString returns the string representation

func (UpdateUserAttributesInput) String 

func (s UpdateUserAttributesInput) String() string

String returns the string representation

func (*UpdateUserAttributesInput) Validate 

func (s *UpdateUserAttributesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UpdateUserAttributesOutput 

type UpdateUserAttributesOutput struct {

	// The code delivery details list from the server for the request to update
	// user attributes.
	CodeDeliveryDetailsList []*CodeDeliveryDetailsType `type:"list"`
	// contains filtered or unexported fields
}

Represents the response from the server for the request to update user attributes.

func (UpdateUserAttributesOutput) GoString 

func (s UpdateUserAttributesOutput) GoString() string

GoString returns the string representation

func (UpdateUserAttributesOutput) String 

func (s UpdateUserAttributesOutput) String() string

String returns the string representation

type UpdateUserPoolClientInput 

type UpdateUserPoolClientInput struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string" required:"true"`

	// The client name from the update user pool client request.
	ClientName *string `min:"1" type:"string"`

	// Explicit authentication flows.
	ExplicitAuthFlows []*string `type:"list"`

	// The read-only attributes of the user pool.
	ReadAttributes []*string `type:"list"`

	// The validity of the refresh token.
	RefreshTokenValidity *int64 `type:"integer"`

	// The user pool ID for the user pool where you want to update the user pool
	// client.
	UserPoolId *string `min:"1" type:"string" required:"true"`

	// The writeable attributes of the user pool.
	WriteAttributes []*string `type:"list"`
	// contains filtered or unexported fields
}

Represents the request to update the user pool client.

func (UpdateUserPoolClientInput) GoString 

func (s UpdateUserPoolClientInput) GoString() string

GoString returns the string representation

func (UpdateUserPoolClientInput) String 

func (s UpdateUserPoolClientInput) String() string

String returns the string representation

func (*UpdateUserPoolClientInput) Validate 

func (s *UpdateUserPoolClientInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UpdateUserPoolClientOutput 

type UpdateUserPoolClientOutput struct {

	// The user pool client value from the response from the server when an update
	// user pool client request is made.
	UserPoolClient *UserPoolClientType `type:"structure"`
	// contains filtered or unexported fields
}

Represents the response from the server to the request to update the user pool client.

func (UpdateUserPoolClientOutput) GoString 

func (s UpdateUserPoolClientOutput) GoString() string

GoString returns the string representation

func (UpdateUserPoolClientOutput) String 

func (s UpdateUserPoolClientOutput) String() string

String returns the string representation

type UpdateUserPoolInput 

type UpdateUserPoolInput struct {

	// The attributes that are automatically verified when the Amazon Cognito service
	// makes a request to update user pools.
	AutoVerifiedAttributes []*string `type:"list"`

	// Device configuration.
	DeviceConfiguration *DeviceConfigurationType `type:"structure"`

	// Email configuration.
	EmailConfiguration *EmailConfigurationType `type:"structure"`

	// The contents of the email verification message.
	EmailVerificationMessage *string `min:"6" type:"string"`

	// The subject of the email verfication message
	EmailVerificationSubject *string `min:"1" type:"string"`

	// The AWS Lambda configuration information from the request to update the user
	// pool.
	LambdaConfig *LambdaConfigType `type:"structure"`

	// Can be one of the following values:
	//
	//  OFF - MFA tokens are not required and cannot be specified during user registration.
	// ON - MFA tokens are required for all user registrations. You can only specify
	// required when you are initially creating a user pool. OPTIONAL - Users have
	// the option when registering to create an MFA token.
	MfaConfiguration *string `type:"string" enum:"UserPoolMfaType"`

	// A container with the policies you wish to update in a user pool.
	Policies *UserPoolPolicyType `type:"structure"`

	// The contents of the SMS authentication message.
	SmsAuthenticationMessage *string `min:"6" type:"string"`

	// SMS configuration.
	SmsConfiguration *SmsConfigurationType `type:"structure"`

	// A container with information about the SMS verification message.
	SmsVerificationMessage *string `min:"6" type:"string"`

	// The user pool ID for the user pool you want to update.
	UserPoolId *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to update the user pool.

func (UpdateUserPoolInput) GoString 

func (s UpdateUserPoolInput) GoString() string

GoString returns the string representation

func (UpdateUserPoolInput) String 

func (s UpdateUserPoolInput) String() string

String returns the string representation

func (*UpdateUserPoolInput) Validate 

func (s *UpdateUserPoolInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UpdateUserPoolOutput 

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

Represents the response from the server when you make a request to update the user pool.

func (UpdateUserPoolOutput) GoString 

func (s UpdateUserPoolOutput) GoString() string

GoString returns the string representation

func (UpdateUserPoolOutput) String 

func (s UpdateUserPoolOutput) String() string

String returns the string representation

type UserPoolClientDescription 

type UserPoolClientDescription struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string"`

	// The client name from the user pool client description.
	ClientName *string `min:"1" type:"string"`

	// The user pool ID for the user pool where you want to describe the user pool
	// client.
	UserPoolId *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

The description of the user poool client.

func (UserPoolClientDescription) GoString 

func (s UserPoolClientDescription) GoString() string

GoString returns the string representation

func (UserPoolClientDescription) String 

func (s UserPoolClientDescription) String() string

String returns the string representation

type UserPoolClientType 

type UserPoolClientType struct {

	// The ID of the client associated with the user pool.
	ClientId *string `min:"1" type:"string"`

	// The client name from the user pool request of the client type.
	ClientName *string `min:"1" type:"string"`

	// The client secret from the user pool request of the client type.
	ClientSecret *string `min:"1" type:"string"`

	// The creation date from the user pool request of the client type.
	CreationDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The explicit authentication flows.
	ExplicitAuthFlows []*string `type:"list"`

	// The last modified date from the user pool request of the client type.
	LastModifiedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Read-only attributes.
	ReadAttributes []*string `type:"list"`

	// The validity of the refresh token.
	RefreshTokenValidity *int64 `type:"integer"`

	// The user pool ID for the user pool client.
	UserPoolId *string `min:"1" type:"string"`

	// The writeable attributes.
	WriteAttributes []*string `type:"list"`
	// contains filtered or unexported fields
}

A user pool of the client type.

func (UserPoolClientType) GoString 

func (s UserPoolClientType) GoString() string

GoString returns the string representation

func (UserPoolClientType) String 

func (s UserPoolClientType) String() string

String returns the string representation

type UserPoolDescriptionType 

type UserPoolDescriptionType struct {

	// The creation date in a user pool description.
	CreationDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The ID in a user pool description.
	Id *string `min:"1" type:"string"`

	// The AWS Lambda configuration information in a user pool description.
	LambdaConfig *LambdaConfigType `type:"structure"`

	// The last modified date in a user pool description.
	LastModifiedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The name in a user pool description.
	Name *string `min:"1" type:"string"`

	// The user pool status in a user pool description.
	Status *string `type:"string" enum:"StatusType"`
	// contains filtered or unexported fields
}

A user pool description.

func (UserPoolDescriptionType) GoString 

func (s UserPoolDescriptionType) GoString() string

GoString returns the string representation

func (UserPoolDescriptionType) String 

func (s UserPoolDescriptionType) String() string

String returns the string representation

type UserPoolPolicyType 

type UserPoolPolicyType struct {

	// A container with information about the user pool password policy.
	PasswordPolicy *PasswordPolicyType `type:"structure"`
	// contains filtered or unexported fields
}

The type of policy in a user pool.

func (UserPoolPolicyType) GoString 

func (s UserPoolPolicyType) GoString() string

GoString returns the string representation

func (UserPoolPolicyType) String 

func (s UserPoolPolicyType) String() string

String returns the string representation

func (*UserPoolPolicyType) Validate 

func (s *UserPoolPolicyType) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UserPoolType 

type UserPoolType struct {

	// Specifies the attributes that are aliased in a user pool.
	AliasAttributes []*string `type:"list"`

	// Specifies the attributes that are auto-verified in a user pool.
	AutoVerifiedAttributes []*string `type:"list"`

	// The creation date of a user pool.
	CreationDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The device configuration.
	DeviceConfiguration *DeviceConfigurationType `type:"structure"`

	// The email configuration.
	EmailConfiguration *EmailConfigurationType `type:"structure"`

	// The reason why the email configuration cannot send the messages to your users.
	EmailConfigurationFailure *string `type:"string"`

	// The contents of the email verification message.
	EmailVerificationMessage *string `min:"6" type:"string"`

	// The subject of the email verification message.
	EmailVerificationSubject *string `min:"1" type:"string"`

	// A number estimating the size of the user pool.
	EstimatedNumberOfUsers *int64 `type:"integer"`

	// The ID of the user pool.
	Id *string `min:"1" type:"string"`

	// A container describing the AWS Lambda triggers associated with a user pool.
	LambdaConfig *LambdaConfigType `type:"structure"`

	// The last modified date of a user pool.
	LastModifiedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// Can be one of the following values:
	//
	//  OFF - MFA tokens are not required and cannot be specified during user registration.
	// ON - MFA tokens are required for all user registrations. You can only specify
	// required when you are initially creating a user pool. OPTIONAL - Users have
	// the option when registering to create an MFA token.
	MfaConfiguration *string `type:"string" enum:"UserPoolMfaType"`

	// The name of the user pool.
	Name *string `min:"1" type:"string"`

	// A container describing the policies associated with a user pool.
	Policies *UserPoolPolicyType `type:"structure"`

	// A container with the schema attributes of a user pool.
	SchemaAttributes []*SchemaAttributeType `min:"1" type:"list"`

	// The contents of the SMS authentication message.
	SmsAuthenticationMessage *string `min:"6" type:"string"`

	// The SMS configuration.
	SmsConfiguration *SmsConfigurationType `type:"structure"`

	// The reason why the SMS configuration cannot send the message(s) to your users.
	SmsConfigurationFailure *string `type:"string"`

	// The contents of the SMS verification message.
	SmsVerificationMessage *string `min:"6" type:"string"`

	// The status of a user pool.
	Status *string `type:"string" enum:"StatusType"`
	// contains filtered or unexported fields
}

A container with information about the user pool type.

func (UserPoolType) GoString 

func (s UserPoolType) GoString() string

GoString returns the string representation

func (UserPoolType) String 

func (s UserPoolType) String() string

String returns the string representation

type UserType 

type UserType struct {

	// A container with information about the user type attributes.
	Attributes []*AttributeType `type:"list"`

	// Specifies whether the user is enabled.
	Enabled *bool `type:"boolean"`

	// The creation date of the user.
	UserCreateDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The last modified date of the user.
	UserLastModifiedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The user status. Can be one of the following:
	//
	//  UNCONFIRMED - User has been created but not confirmed. CONFIRMED - User
	// has been confirmed. ARCHIVED - User is no longer active. COMPROMISED - User
	// is disabled due to a potential security threat. UNKNOWN - User status is
	// not known.
	UserStatus *string `type:"string" enum:"UserStatusType"`

	// The user name of the user you wish to describe.
	Username *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

The user type.

func (UserType) GoString 

func (s UserType) GoString() string

GoString returns the string representation

func (UserType) String 

func (s UserType) String() string

String returns the string representation

type VerifyUserAttributeInput 

type VerifyUserAttributeInput struct {

	// Represents the access token of the request to verify user attributes.
	AccessToken *string `type:"string"`

	// The attribute name in the request to verify user attributes.
	AttributeName *string `min:"1" type:"string" required:"true"`

	// The verification code in the request to verify user attributes.
	Code *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Represents the request to verify user attributes.

func (VerifyUserAttributeInput) GoString 

func (s VerifyUserAttributeInput) GoString() string

GoString returns the string representation

func (VerifyUserAttributeInput) String 

func (s VerifyUserAttributeInput) String() string

String returns the string representation

func (*VerifyUserAttributeInput) Validate 

func (s *VerifyUserAttributeInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type VerifyUserAttributeOutput 

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

A container representing the response from the server from the request to verify user attributes.

func (VerifyUserAttributeOutput) GoString 

func (s VerifyUserAttributeOutput) GoString() string

GoString returns the string representation

func (VerifyUserAttributeOutput) String 

func (s VerifyUserAttributeOutput) String() string

String returns the string representation

Source Files

View all Source files

Directories

Path Synopsis
Package cognitoidentityprovideriface provides an interface for the Amazon Cognito Identity Provider.
 Package cognitoidentityprovideriface provides an interface for the Amazon Cognito Identity Provider.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.