cognitoidentityprovider

package
v1.1.29 Latest Latest
Warning

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

 Go to latest Published: May 19, 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 DeliveryMediumType
	DeliveryMediumTypeSms = "SMS"
	// @enum DeliveryMediumType
	DeliveryMediumTypeEmail = "EMAIL"
)
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"
)
View Source 
const (
	// @enum VerifiedAttributeType
	VerifiedAttributeTypePhoneNumber = "phone_number"
	// @enum VerifiedAttributeType
	VerifiedAttributeTypeEmail = "email"
)
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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 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 added in v1.1.21 

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 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 added in v1.1.21 

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 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 added in v1.1.21 

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 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 added in v1.1.21 

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 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 added in v1.1.21 

func (s *AttributeType) Validate() error

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

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 added in v1.1.21 

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, which is a new capability that is available as a beta. 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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AddCustomAttributes operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AdminConfirmSignUp operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AdminDeleteUserAttributes operation.

func (*CognitoIdentityProvider) AdminDeleteUserRequest 

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

AdminDeleteUserRequest generates a request for the AdminDeleteUser operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AdminDisableUser operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AdminEnableUser operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AdminGetUser operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AdminResetUserPassword operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AdminSetUserSettings operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the AdminUpdateUserAttributes operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the ChangePassword operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the ConfirmForgotPassword operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the ConfirmSignUp operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	params := &cognitoidentityprovider.CreateUserPoolInput{
		PoolName: aws.String("UserPoolNameType"), // Required
		AliasAttributes: []*string{
			aws.String("AliasAttributeType"), // Required
			// More values...
		},
		AutoVerifiedAttributes: []*string{
			aws.String("VerifiedAttributeType"), // Required
			// More values...
		},
		EmailVerificationMessage: aws.String("EmailVerificationMessageType"),
		EmailVerificationSubject: aws.String("EmailVerificationSubjectType"),
		LambdaConfig: &cognitoidentityprovider.LambdaConfigType{
			CustomMessage:      aws.String("ArnType"),
			PostAuthentication: aws.String("ArnType"),
			PostConfirmation:   aws.String("ArnType"),
			PreAuthentication:  aws.String("ArnType"),
			PreSignUp:          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"),
		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() {
	svc := cognitoidentityprovider.New(session.New())

	params := &cognitoidentityprovider.CreateUserPoolClientInput{
		ClientName:     aws.String("ClientNameType"), // Required
		UserPoolId:     aws.String("UserPoolIdType"), // Required
		GenerateSecret: aws.Bool(true),
	}
	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 request for the CreateUserPoolClient operation.

func (*CognitoIdentityProvider) CreateUserPoolRequest 

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

CreateUserPoolRequest generates a request for the CreateUserPool operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the DeleteUserAttributes operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the DeleteUserPoolClient operation.

func (*CognitoIdentityProvider) DeleteUserPoolRequest 

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

DeleteUserPoolRequest generates a request for the DeleteUserPool operation.

func (*CognitoIdentityProvider) DeleteUserRequest 

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

DeleteUserRequest generates a request for the DeleteUser operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the DescribeUserPoolClient operation.

func (*CognitoIdentityProvider) DescribeUserPoolRequest 

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

DescribeUserPoolRequest generates a request for the DescribeUserPool operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the ForgotPassword operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the GetUserAttributeVerificationCode operation.

func (*CognitoIdentityProvider) GetUserRequest 

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

GetUserRequest generates a request for the GetUser operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the ListUserPoolClients operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the ListUserPools operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	params := &cognitoidentityprovider.ListUsersInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		AttributesToGet: []*string{
			aws.String("AttributeNameType"), // Required
			// More values...
		},
		Limit:           aws.Int64(1),
		PaginationToken: aws.String("SearchPaginationTokenType"),
		UserStatus:      aws.String("UserStatusType"),
	}
	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 request for the ListUsers operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the ResendConfirmationCode operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the SetUserSettings operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the SignUp operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the UpdateUserAttributes operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	params := &cognitoidentityprovider.UpdateUserPoolInput{
		UserPoolId: aws.String("UserPoolIdType"), // Required
		AutoVerifiedAttributes: []*string{
			aws.String("VerifiedAttributeType"), // Required
			// More values...
		},
		EmailVerificationMessage: aws.String("EmailVerificationMessageType"),
		EmailVerificationSubject: aws.String("EmailVerificationSubjectType"),
		LambdaConfig: &cognitoidentityprovider.LambdaConfigType{
			CustomMessage:      aws.String("ArnType"),
			PostAuthentication: aws.String("ArnType"),
			PostConfirmation:   aws.String("ArnType"),
			PreAuthentication:  aws.String("ArnType"),
			PreSignUp:          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"),
		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() {
	svc := cognitoidentityprovider.New(session.New())

	params := &cognitoidentityprovider.UpdateUserPoolClientInput{
		ClientId:   aws.String("ClientIdType"),   // Required
		UserPoolId: aws.String("UserPoolIdType"), // Required
		ClientName: aws.String("ClientNameType"),
	}
	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 request for the UpdateUserPoolClient operation.

func (*CognitoIdentityProvider) UpdateUserPoolRequest 

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

UpdateUserPoolRequest generates a request for the UpdateUserPool operation.

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() {
	svc := cognitoidentityprovider.New(session.New())

	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 request for the VerifyUserAttribute operation.

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 added in v1.1.21 

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 added in v1.1.21 

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"`

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

	// 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"`
	// 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 added in v1.1.21 

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"`

	// 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"`

	// 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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 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 added in v1.1.21 

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 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 added in v1.1.21 

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 LambdaConfigType 

type LambdaConfigType struct {

	// A custom Message AWS Lambda trigger.
	CustomMessage *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"`
	// 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 added in v1.1.21 

func (s *LambdaConfigType) Validate() error

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

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 added in v1.1.21 

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 added in v1.1.21 

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 limit of the request to list users.
	Limit *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.
	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"`

	// 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"`
	// 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 added in v1.1.21 

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 added in v1.1.21 

func (s *MFAOptionType) Validate() error

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

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 added in v1.1.21 

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 added in v1.1.21 

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 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 added in v1.1.21 

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 added in v1.1.21 

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 added in v1.1.21 

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 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 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 added in v1.1.21 

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"`

	// 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"`
	// 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 added in v1.1.21 

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"`

	// 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"`

	// 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 added in v1.1.21 

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 last modified date from the user pool request of the client type.
	LastModifiedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The user pool ID for the user pool client.
	UserPoolId *string `min:"1" type:"string"`
	// 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 added in v1.1.21 

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 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 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 added in v1.1.21 

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.