api.go

// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.

// Package cognitoidentityprovider provides a client for Amazon Cognito Identity Provider.
package cognitoidentityprovider

import (
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/credentials"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/private/protocol"
	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
)

const opAddCustomAttributes = "AddCustomAttributes"

// AddCustomAttributesRequest generates a request for the AddCustomAttributes operation.
func (c *CognitoIdentityProvider) AddCustomAttributesRequest(input *AddCustomAttributesInput) (req *request.Request, output *AddCustomAttributesOutput) {
	op := &request.Operation{
		Name:       opAddCustomAttributes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AddCustomAttributesInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AddCustomAttributesOutput{}
	req.Data = output
	return
}

// Adds additional user attributes to the user pool schema.
func (c *CognitoIdentityProvider) AddCustomAttributes(input *AddCustomAttributesInput) (*AddCustomAttributesOutput, error) {
	req, out := c.AddCustomAttributesRequest(input)
	err := req.Send()
	return out, err
}

const opAdminConfirmSignUp = "AdminConfirmSignUp"

// AdminConfirmSignUpRequest generates a request for the AdminConfirmSignUp operation.
func (c *CognitoIdentityProvider) AdminConfirmSignUpRequest(input *AdminConfirmSignUpInput) (req *request.Request, output *AdminConfirmSignUpOutput) {
	op := &request.Operation{
		Name:       opAdminConfirmSignUp,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminConfirmSignUpInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AdminConfirmSignUpOutput{}
	req.Data = output
	return
}

// Confirms user registration as an admin without using a confirmation code.
// Works on any user.
func (c *CognitoIdentityProvider) AdminConfirmSignUp(input *AdminConfirmSignUpInput) (*AdminConfirmSignUpOutput, error) {
	req, out := c.AdminConfirmSignUpRequest(input)
	err := req.Send()
	return out, err
}

const opAdminDeleteUser = "AdminDeleteUser"

// AdminDeleteUserRequest generates a request for the AdminDeleteUser operation.
func (c *CognitoIdentityProvider) AdminDeleteUserRequest(input *AdminDeleteUserInput) (req *request.Request, output *AdminDeleteUserOutput) {
	op := &request.Operation{
		Name:       opAdminDeleteUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminDeleteUserInput{}
	}

	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &AdminDeleteUserOutput{}
	req.Data = output
	return
}

// Deletes a user as an administrator. Works on any user.
func (c *CognitoIdentityProvider) AdminDeleteUser(input *AdminDeleteUserInput) (*AdminDeleteUserOutput, error) {
	req, out := c.AdminDeleteUserRequest(input)
	err := req.Send()
	return out, err
}

const opAdminDeleteUserAttributes = "AdminDeleteUserAttributes"

// AdminDeleteUserAttributesRequest generates a request for the AdminDeleteUserAttributes operation.
func (c *CognitoIdentityProvider) AdminDeleteUserAttributesRequest(input *AdminDeleteUserAttributesInput) (req *request.Request, output *AdminDeleteUserAttributesOutput) {
	op := &request.Operation{
		Name:       opAdminDeleteUserAttributes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminDeleteUserAttributesInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AdminDeleteUserAttributesOutput{}
	req.Data = output
	return
}

// Deletes the user attributes in a user pool as an administrator. Works on
// any user.
func (c *CognitoIdentityProvider) AdminDeleteUserAttributes(input *AdminDeleteUserAttributesInput) (*AdminDeleteUserAttributesOutput, error) {
	req, out := c.AdminDeleteUserAttributesRequest(input)
	err := req.Send()
	return out, err
}

const opAdminDisableUser = "AdminDisableUser"

// AdminDisableUserRequest generates a request for the AdminDisableUser operation.
func (c *CognitoIdentityProvider) AdminDisableUserRequest(input *AdminDisableUserInput) (req *request.Request, output *AdminDisableUserOutput) {
	op := &request.Operation{
		Name:       opAdminDisableUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminDisableUserInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AdminDisableUserOutput{}
	req.Data = output
	return
}

// Disables the specified user as an administrator. Works on any user.
func (c *CognitoIdentityProvider) AdminDisableUser(input *AdminDisableUserInput) (*AdminDisableUserOutput, error) {
	req, out := c.AdminDisableUserRequest(input)
	err := req.Send()
	return out, err
}

const opAdminEnableUser = "AdminEnableUser"

// AdminEnableUserRequest generates a request for the AdminEnableUser operation.
func (c *CognitoIdentityProvider) AdminEnableUserRequest(input *AdminEnableUserInput) (req *request.Request, output *AdminEnableUserOutput) {
	op := &request.Operation{
		Name:       opAdminEnableUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminEnableUserInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AdminEnableUserOutput{}
	req.Data = output
	return
}

// Enables the specified user as an administrator. Works on any user.
func (c *CognitoIdentityProvider) AdminEnableUser(input *AdminEnableUserInput) (*AdminEnableUserOutput, error) {
	req, out := c.AdminEnableUserRequest(input)
	err := req.Send()
	return out, err
}

const opAdminGetUser = "AdminGetUser"

// AdminGetUserRequest generates a request for the AdminGetUser operation.
func (c *CognitoIdentityProvider) AdminGetUserRequest(input *AdminGetUserInput) (req *request.Request, output *AdminGetUserOutput) {
	op := &request.Operation{
		Name:       opAdminGetUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminGetUserInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AdminGetUserOutput{}
	req.Data = output
	return
}

// Gets the specified user by user name in a user pool as an administrator.
// Works on any user.
func (c *CognitoIdentityProvider) AdminGetUser(input *AdminGetUserInput) (*AdminGetUserOutput, error) {
	req, out := c.AdminGetUserRequest(input)
	err := req.Send()
	return out, err
}

const opAdminResetUserPassword = "AdminResetUserPassword"

// AdminResetUserPasswordRequest generates a request for the AdminResetUserPassword operation.
func (c *CognitoIdentityProvider) AdminResetUserPasswordRequest(input *AdminResetUserPasswordInput) (req *request.Request, output *AdminResetUserPasswordOutput) {
	op := &request.Operation{
		Name:       opAdminResetUserPassword,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminResetUserPasswordInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AdminResetUserPasswordOutput{}
	req.Data = output
	return
}

// Resets the specified user's password in a user pool as an administrator.
// Works on any user.
func (c *CognitoIdentityProvider) AdminResetUserPassword(input *AdminResetUserPasswordInput) (*AdminResetUserPasswordOutput, error) {
	req, out := c.AdminResetUserPasswordRequest(input)
	err := req.Send()
	return out, err
}

const opAdminSetUserSettings = "AdminSetUserSettings"

// AdminSetUserSettingsRequest generates a request for the AdminSetUserSettings operation.
func (c *CognitoIdentityProvider) AdminSetUserSettingsRequest(input *AdminSetUserSettingsInput) (req *request.Request, output *AdminSetUserSettingsOutput) {
	op := &request.Operation{
		Name:       opAdminSetUserSettings,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminSetUserSettingsInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AdminSetUserSettingsOutput{}
	req.Data = output
	return
}

// Sets all the user settings for a specified user name. Works on any user.
func (c *CognitoIdentityProvider) AdminSetUserSettings(input *AdminSetUserSettingsInput) (*AdminSetUserSettingsOutput, error) {
	req, out := c.AdminSetUserSettingsRequest(input)
	err := req.Send()
	return out, err
}

const opAdminUpdateUserAttributes = "AdminUpdateUserAttributes"

// AdminUpdateUserAttributesRequest generates a request for the AdminUpdateUserAttributes operation.
func (c *CognitoIdentityProvider) AdminUpdateUserAttributesRequest(input *AdminUpdateUserAttributesInput) (req *request.Request, output *AdminUpdateUserAttributesOutput) {
	op := &request.Operation{
		Name:       opAdminUpdateUserAttributes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AdminUpdateUserAttributesInput{}
	}

	req = c.newRequest(op, input, output)
	output = &AdminUpdateUserAttributesOutput{}
	req.Data = output
	return
}

// Updates the specified user's attributes, including developer attributes,
// as an administrator. Works on any user.
func (c *CognitoIdentityProvider) AdminUpdateUserAttributes(input *AdminUpdateUserAttributesInput) (*AdminUpdateUserAttributesOutput, error) {
	req, out := c.AdminUpdateUserAttributesRequest(input)
	err := req.Send()
	return out, err
}

const opChangePassword = "ChangePassword"

// ChangePasswordRequest generates a request for the ChangePassword operation.
func (c *CognitoIdentityProvider) ChangePasswordRequest(input *ChangePasswordInput) (req *request.Request, output *ChangePasswordOutput) {
	op := &request.Operation{
		Name:       opChangePassword,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ChangePasswordInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &ChangePasswordOutput{}
	req.Data = output
	return
}

// Changes the password for a specified user in a user pool.
func (c *CognitoIdentityProvider) ChangePassword(input *ChangePasswordInput) (*ChangePasswordOutput, error) {
	req, out := c.ChangePasswordRequest(input)
	err := req.Send()
	return out, err
}

const opConfirmForgotPassword = "ConfirmForgotPassword"

// ConfirmForgotPasswordRequest generates a request for the ConfirmForgotPassword operation.
func (c *CognitoIdentityProvider) ConfirmForgotPasswordRequest(input *ConfirmForgotPasswordInput) (req *request.Request, output *ConfirmForgotPasswordOutput) {
	op := &request.Operation{
		Name:       opConfirmForgotPassword,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ConfirmForgotPasswordInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &ConfirmForgotPasswordOutput{}
	req.Data = output
	return
}

// Allows a user to enter a code provided when they reset their password to
// update their password.
func (c *CognitoIdentityProvider) ConfirmForgotPassword(input *ConfirmForgotPasswordInput) (*ConfirmForgotPasswordOutput, error) {
	req, out := c.ConfirmForgotPasswordRequest(input)
	err := req.Send()
	return out, err
}

const opConfirmSignUp = "ConfirmSignUp"

// ConfirmSignUpRequest generates a request for the ConfirmSignUp operation.
func (c *CognitoIdentityProvider) ConfirmSignUpRequest(input *ConfirmSignUpInput) (req *request.Request, output *ConfirmSignUpOutput) {
	op := &request.Operation{
		Name:       opConfirmSignUp,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ConfirmSignUpInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &ConfirmSignUpOutput{}
	req.Data = output
	return
}

// Confirms registration of a user and handles the existing alias from a previous
// user.
func (c *CognitoIdentityProvider) ConfirmSignUp(input *ConfirmSignUpInput) (*ConfirmSignUpOutput, error) {
	req, out := c.ConfirmSignUpRequest(input)
	err := req.Send()
	return out, err
}

const opCreateUserPool = "CreateUserPool"

// CreateUserPoolRequest generates a request for the CreateUserPool operation.
func (c *CognitoIdentityProvider) CreateUserPoolRequest(input *CreateUserPoolInput) (req *request.Request, output *CreateUserPoolOutput) {
	op := &request.Operation{
		Name:       opCreateUserPool,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateUserPoolInput{}
	}

	req = c.newRequest(op, input, output)
	output = &CreateUserPoolOutput{}
	req.Data = output
	return
}

// Creates a new Amazon Cognito user pool and sets the password policy for the
// pool.
func (c *CognitoIdentityProvider) CreateUserPool(input *CreateUserPoolInput) (*CreateUserPoolOutput, error) {
	req, out := c.CreateUserPoolRequest(input)
	err := req.Send()
	return out, err
}

const opCreateUserPoolClient = "CreateUserPoolClient"

// CreateUserPoolClientRequest generates a request for the CreateUserPoolClient operation.
func (c *CognitoIdentityProvider) CreateUserPoolClientRequest(input *CreateUserPoolClientInput) (req *request.Request, output *CreateUserPoolClientOutput) {
	op := &request.Operation{
		Name:       opCreateUserPoolClient,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateUserPoolClientInput{}
	}

	req = c.newRequest(op, input, output)
	output = &CreateUserPoolClientOutput{}
	req.Data = output
	return
}

// Creates the user pool client.
func (c *CognitoIdentityProvider) CreateUserPoolClient(input *CreateUserPoolClientInput) (*CreateUserPoolClientOutput, error) {
	req, out := c.CreateUserPoolClientRequest(input)
	err := req.Send()
	return out, err
}

const opDeleteUser = "DeleteUser"

// DeleteUserRequest generates a request for the DeleteUser operation.
func (c *CognitoIdentityProvider) DeleteUserRequest(input *DeleteUserInput) (req *request.Request, output *DeleteUserOutput) {
	op := &request.Operation{
		Name:       opDeleteUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteUserInput{}
	}

	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &DeleteUserOutput{}
	req.Data = output
	return
}

// Allows a user to delete one's self.
func (c *CognitoIdentityProvider) DeleteUser(input *DeleteUserInput) (*DeleteUserOutput, error) {
	req, out := c.DeleteUserRequest(input)
	err := req.Send()
	return out, err
}

const opDeleteUserAttributes = "DeleteUserAttributes"

// DeleteUserAttributesRequest generates a request for the DeleteUserAttributes operation.
func (c *CognitoIdentityProvider) DeleteUserAttributesRequest(input *DeleteUserAttributesInput) (req *request.Request, output *DeleteUserAttributesOutput) {
	op := &request.Operation{
		Name:       opDeleteUserAttributes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteUserAttributesInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &DeleteUserAttributesOutput{}
	req.Data = output
	return
}

// Deletes the attributes for a user.
func (c *CognitoIdentityProvider) DeleteUserAttributes(input *DeleteUserAttributesInput) (*DeleteUserAttributesOutput, error) {
	req, out := c.DeleteUserAttributesRequest(input)
	err := req.Send()
	return out, err
}

const opDeleteUserPool = "DeleteUserPool"

// DeleteUserPoolRequest generates a request for the DeleteUserPool operation.
func (c *CognitoIdentityProvider) DeleteUserPoolRequest(input *DeleteUserPoolInput) (req *request.Request, output *DeleteUserPoolOutput) {
	op := &request.Operation{
		Name:       opDeleteUserPool,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteUserPoolInput{}
	}

	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteUserPoolOutput{}
	req.Data = output
	return
}

// Deletes the specified Amazon Cognito user pool.
func (c *CognitoIdentityProvider) DeleteUserPool(input *DeleteUserPoolInput) (*DeleteUserPoolOutput, error) {
	req, out := c.DeleteUserPoolRequest(input)
	err := req.Send()
	return out, err
}

const opDeleteUserPoolClient = "DeleteUserPoolClient"

// DeleteUserPoolClientRequest generates a request for the DeleteUserPoolClient operation.
func (c *CognitoIdentityProvider) DeleteUserPoolClientRequest(input *DeleteUserPoolClientInput) (req *request.Request, output *DeleteUserPoolClientOutput) {
	op := &request.Operation{
		Name:       opDeleteUserPoolClient,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteUserPoolClientInput{}
	}

	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteUserPoolClientOutput{}
	req.Data = output
	return
}

// Allows the developer to delete the user pool client.
func (c *CognitoIdentityProvider) DeleteUserPoolClient(input *DeleteUserPoolClientInput) (*DeleteUserPoolClientOutput, error) {
	req, out := c.DeleteUserPoolClientRequest(input)
	err := req.Send()
	return out, err
}

const opDescribeUserPool = "DescribeUserPool"

// DescribeUserPoolRequest generates a request for the DescribeUserPool operation.
func (c *CognitoIdentityProvider) DescribeUserPoolRequest(input *DescribeUserPoolInput) (req *request.Request, output *DescribeUserPoolOutput) {
	op := &request.Operation{
		Name:       opDescribeUserPool,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeUserPoolInput{}
	}

	req = c.newRequest(op, input, output)
	output = &DescribeUserPoolOutput{}
	req.Data = output
	return
}

// Returns the configuration information and metadata of the specified user
// pool.
func (c *CognitoIdentityProvider) DescribeUserPool(input *DescribeUserPoolInput) (*DescribeUserPoolOutput, error) {
	req, out := c.DescribeUserPoolRequest(input)
	err := req.Send()
	return out, err
}

const opDescribeUserPoolClient = "DescribeUserPoolClient"

// DescribeUserPoolClientRequest generates a request for the DescribeUserPoolClient operation.
func (c *CognitoIdentityProvider) DescribeUserPoolClientRequest(input *DescribeUserPoolClientInput) (req *request.Request, output *DescribeUserPoolClientOutput) {
	op := &request.Operation{
		Name:       opDescribeUserPoolClient,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeUserPoolClientInput{}
	}

	req = c.newRequest(op, input, output)
	output = &DescribeUserPoolClientOutput{}
	req.Data = output
	return
}

// Client method for returning the configuration information and metadata of
// the specified user pool client.
func (c *CognitoIdentityProvider) DescribeUserPoolClient(input *DescribeUserPoolClientInput) (*DescribeUserPoolClientOutput, error) {
	req, out := c.DescribeUserPoolClientRequest(input)
	err := req.Send()
	return out, err
}

const opForgotPassword = "ForgotPassword"

// ForgotPasswordRequest generates a request for the ForgotPassword operation.
func (c *CognitoIdentityProvider) ForgotPasswordRequest(input *ForgotPasswordInput) (req *request.Request, output *ForgotPasswordOutput) {
	op := &request.Operation{
		Name:       opForgotPassword,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ForgotPasswordInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &ForgotPasswordOutput{}
	req.Data = output
	return
}

// Retrieves the password for the specified client ID or username.
func (c *CognitoIdentityProvider) ForgotPassword(input *ForgotPasswordInput) (*ForgotPasswordOutput, error) {
	req, out := c.ForgotPasswordRequest(input)
	err := req.Send()
	return out, err
}

const opGetUser = "GetUser"

// GetUserRequest generates a request for the GetUser operation.
func (c *CognitoIdentityProvider) GetUserRequest(input *GetUserInput) (req *request.Request, output *GetUserOutput) {
	op := &request.Operation{
		Name:       opGetUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetUserInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &GetUserOutput{}
	req.Data = output
	return
}

// Gets the user attributes and metadata for a user.
func (c *CognitoIdentityProvider) GetUser(input *GetUserInput) (*GetUserOutput, error) {
	req, out := c.GetUserRequest(input)
	err := req.Send()
	return out, err
}

const opGetUserAttributeVerificationCode = "GetUserAttributeVerificationCode"

// GetUserAttributeVerificationCodeRequest generates a request for the GetUserAttributeVerificationCode operation.
func (c *CognitoIdentityProvider) GetUserAttributeVerificationCodeRequest(input *GetUserAttributeVerificationCodeInput) (req *request.Request, output *GetUserAttributeVerificationCodeOutput) {
	op := &request.Operation{
		Name:       opGetUserAttributeVerificationCode,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetUserAttributeVerificationCodeInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &GetUserAttributeVerificationCodeOutput{}
	req.Data = output
	return
}

// Gets the user attribute verification code for the specified attribute name.
func (c *CognitoIdentityProvider) GetUserAttributeVerificationCode(input *GetUserAttributeVerificationCodeInput) (*GetUserAttributeVerificationCodeOutput, error) {
	req, out := c.GetUserAttributeVerificationCodeRequest(input)
	err := req.Send()
	return out, err
}

const opListUserPoolClients = "ListUserPoolClients"

// ListUserPoolClientsRequest generates a request for the ListUserPoolClients operation.
func (c *CognitoIdentityProvider) ListUserPoolClientsRequest(input *ListUserPoolClientsInput) (req *request.Request, output *ListUserPoolClientsOutput) {
	op := &request.Operation{
		Name:       opListUserPoolClients,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListUserPoolClientsInput{}
	}

	req = c.newRequest(op, input, output)
	output = &ListUserPoolClientsOutput{}
	req.Data = output
	return
}

// Lists the clients that have been created for the specified user pool.
func (c *CognitoIdentityProvider) ListUserPoolClients(input *ListUserPoolClientsInput) (*ListUserPoolClientsOutput, error) {
	req, out := c.ListUserPoolClientsRequest(input)
	err := req.Send()
	return out, err
}

const opListUserPools = "ListUserPools"

// ListUserPoolsRequest generates a request for the ListUserPools operation.
func (c *CognitoIdentityProvider) ListUserPoolsRequest(input *ListUserPoolsInput) (req *request.Request, output *ListUserPoolsOutput) {
	op := &request.Operation{
		Name:       opListUserPools,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListUserPoolsInput{}
	}

	req = c.newRequest(op, input, output)
	output = &ListUserPoolsOutput{}
	req.Data = output
	return
}

// Lists the user pools associated with an AWS account.
func (c *CognitoIdentityProvider) ListUserPools(input *ListUserPoolsInput) (*ListUserPoolsOutput, error) {
	req, out := c.ListUserPoolsRequest(input)
	err := req.Send()
	return out, err
}

const opListUsers = "ListUsers"

// ListUsersRequest generates a request for the ListUsers operation.
func (c *CognitoIdentityProvider) ListUsersRequest(input *ListUsersInput) (req *request.Request, output *ListUsersOutput) {
	op := &request.Operation{
		Name:       opListUsers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListUsersInput{}
	}

	req = c.newRequest(op, input, output)
	output = &ListUsersOutput{}
	req.Data = output
	return
}

// Lists the users in the Amazon Cognito user pool.
func (c *CognitoIdentityProvider) ListUsers(input *ListUsersInput) (*ListUsersOutput, error) {
	req, out := c.ListUsersRequest(input)
	err := req.Send()
	return out, err
}

const opResendConfirmationCode = "ResendConfirmationCode"

// ResendConfirmationCodeRequest generates a request for the ResendConfirmationCode operation.
func (c *CognitoIdentityProvider) ResendConfirmationCodeRequest(input *ResendConfirmationCodeInput) (req *request.Request, output *ResendConfirmationCodeOutput) {
	op := &request.Operation{
		Name:       opResendConfirmationCode,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ResendConfirmationCodeInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &ResendConfirmationCodeOutput{}
	req.Data = output
	return
}

// Resends the confirmation (for confirmation of registration) to a specific
// user in the user pool.
func (c *CognitoIdentityProvider) ResendConfirmationCode(input *ResendConfirmationCodeInput) (*ResendConfirmationCodeOutput, error) {
	req, out := c.ResendConfirmationCodeRequest(input)
	err := req.Send()
	return out, err
}

const opSetUserSettings = "SetUserSettings"

// SetUserSettingsRequest generates a request for the SetUserSettings operation.
func (c *CognitoIdentityProvider) SetUserSettingsRequest(input *SetUserSettingsInput) (req *request.Request, output *SetUserSettingsOutput) {
	op := &request.Operation{
		Name:       opSetUserSettings,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &SetUserSettingsInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &SetUserSettingsOutput{}
	req.Data = output
	return
}

// 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.
func (c *CognitoIdentityProvider) SetUserSettings(input *SetUserSettingsInput) (*SetUserSettingsOutput, error) {
	req, out := c.SetUserSettingsRequest(input)
	err := req.Send()
	return out, err
}

const opSignUp = "SignUp"

// SignUpRequest generates a request for the SignUp operation.
func (c *CognitoIdentityProvider) SignUpRequest(input *SignUpInput) (req *request.Request, output *SignUpOutput) {
	op := &request.Operation{
		Name:       opSignUp,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &SignUpInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &SignUpOutput{}
	req.Data = output
	return
}

// Registers the user in the specified user pool and creates a user name, password,
// and user attributes.
func (c *CognitoIdentityProvider) SignUp(input *SignUpInput) (*SignUpOutput, error) {
	req, out := c.SignUpRequest(input)
	err := req.Send()
	return out, err
}

const opUpdateUserAttributes = "UpdateUserAttributes"

// UpdateUserAttributesRequest generates a request for the UpdateUserAttributes operation.
func (c *CognitoIdentityProvider) UpdateUserAttributesRequest(input *UpdateUserAttributesInput) (req *request.Request, output *UpdateUserAttributesOutput) {
	op := &request.Operation{
		Name:       opUpdateUserAttributes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateUserAttributesInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &UpdateUserAttributesOutput{}
	req.Data = output
	return
}

// Allows a user to update a specific attribute (one at a time).
func (c *CognitoIdentityProvider) UpdateUserAttributes(input *UpdateUserAttributesInput) (*UpdateUserAttributesOutput, error) {
	req, out := c.UpdateUserAttributesRequest(input)
	err := req.Send()
	return out, err
}

const opUpdateUserPool = "UpdateUserPool"

// UpdateUserPoolRequest generates a request for the UpdateUserPool operation.
func (c *CognitoIdentityProvider) UpdateUserPoolRequest(input *UpdateUserPoolInput) (req *request.Request, output *UpdateUserPoolOutput) {
	op := &request.Operation{
		Name:       opUpdateUserPool,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateUserPoolInput{}
	}

	req = c.newRequest(op, input, output)
	output = &UpdateUserPoolOutput{}
	req.Data = output
	return
}

// Updates the specified user pool with the specified attributes.
func (c *CognitoIdentityProvider) UpdateUserPool(input *UpdateUserPoolInput) (*UpdateUserPoolOutput, error) {
	req, out := c.UpdateUserPoolRequest(input)
	err := req.Send()
	return out, err
}

const opUpdateUserPoolClient = "UpdateUserPoolClient"

// UpdateUserPoolClientRequest generates a request for the UpdateUserPoolClient operation.
func (c *CognitoIdentityProvider) UpdateUserPoolClientRequest(input *UpdateUserPoolClientInput) (req *request.Request, output *UpdateUserPoolClientOutput) {
	op := &request.Operation{
		Name:       opUpdateUserPoolClient,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateUserPoolClientInput{}
	}

	req = c.newRequest(op, input, output)
	output = &UpdateUserPoolClientOutput{}
	req.Data = output
	return
}

// Allows the developer to update the specified user pool client and password
// policy.
func (c *CognitoIdentityProvider) UpdateUserPoolClient(input *UpdateUserPoolClientInput) (*UpdateUserPoolClientOutput, error) {
	req, out := c.UpdateUserPoolClientRequest(input)
	err := req.Send()
	return out, err
}

const opVerifyUserAttribute = "VerifyUserAttribute"

// VerifyUserAttributeRequest generates a request for the VerifyUserAttribute operation.
func (c *CognitoIdentityProvider) VerifyUserAttributeRequest(input *VerifyUserAttributeInput) (req *request.Request, output *VerifyUserAttributeOutput) {
	op := &request.Operation{
		Name:       opVerifyUserAttribute,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &VerifyUserAttributeInput{}
	}

	req = c.newRequest(op, input, output)
	req.Config.Credentials = credentials.AnonymousCredentials
	output = &VerifyUserAttributeOutput{}
	req.Data = output
	return
}

// Verifies the specified user attributes in the user pool.
func (c *CognitoIdentityProvider) VerifyUserAttribute(input *VerifyUserAttributeInput) (*VerifyUserAttributeOutput, error) {
	req, out := c.VerifyUserAttributeRequest(input)
	err := req.Send()
	return out, err
}

// Represents the request to add custom attributes.
type AddCustomAttributesInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AddCustomAttributesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AddCustomAttributesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AddCustomAttributesInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AddCustomAttributesInput"}
	if s.CustomAttributes == nil {
		invalidParams.Add(request.NewErrParamRequired("CustomAttributes"))
	}
	if s.CustomAttributes != nil && len(s.CustomAttributes) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("CustomAttributes", 1))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.CustomAttributes != nil {
		for i, v := range s.CustomAttributes {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "CustomAttributes", i), err.(request.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server for the request to add custom attributes.
type AddCustomAttributesOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AddCustomAttributesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AddCustomAttributesOutput) GoString() string {
	return s.String()
}

// Represents the request to confirm user registration.
type AdminConfirmSignUpInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminConfirmSignUpInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminConfirmSignUpInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminConfirmSignUpInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminConfirmSignUpInput"}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server for the request to confirm registration.
type AdminConfirmSignUpOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AdminConfirmSignUpOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminConfirmSignUpOutput) GoString() string {
	return s.String()
}

// Represents the request to delete user attributes as an administrator.
type AdminDeleteUserAttributesInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminDeleteUserAttributesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminDeleteUserAttributesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminDeleteUserAttributesInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminDeleteUserAttributesInput"}
	if s.UserAttributeNames == nil {
		invalidParams.Add(request.NewErrParamRequired("UserAttributeNames"))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response received from the server for a request to delete
// user attributes.
type AdminDeleteUserAttributesOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AdminDeleteUserAttributesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminDeleteUserAttributesOutput) GoString() string {
	return s.String()
}

// Represents the request to delete a user as an administrator.
type AdminDeleteUserInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminDeleteUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminDeleteUserInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminDeleteUserInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminDeleteUserInput"}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

type AdminDeleteUserOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AdminDeleteUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminDeleteUserOutput) GoString() string {
	return s.String()
}

// Represents the request to disable any user as an administrator.
type AdminDisableUserInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminDisableUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminDisableUserInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminDisableUserInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminDisableUserInput"}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response received from the server to disable the user as an
// administrator.
type AdminDisableUserOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AdminDisableUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminDisableUserOutput) GoString() string {
	return s.String()
}

// Represents the request that enables the user as an administrator.
type AdminEnableUserInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminEnableUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminEnableUserInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminEnableUserInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminEnableUserInput"}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server for the request to enable a user
// as an administrator.
type AdminEnableUserOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AdminEnableUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminEnableUserOutput) GoString() string {
	return s.String()
}

// Represents the request to get the specified user as an administrator.
type AdminGetUserInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminGetUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminGetUserInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminGetUserInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminGetUserInput"}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server from the request to get the specified
// user as an administrator.
type AdminGetUserOutput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminGetUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminGetUserOutput) GoString() string {
	return s.String()
}

// Represents the request to reset a user's password as an administrator.
type AdminResetUserPasswordInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminResetUserPasswordInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminResetUserPasswordInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminResetUserPasswordInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminResetUserPasswordInput"}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server to reset a user password as an administrator.
type AdminResetUserPasswordOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AdminResetUserPasswordOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminResetUserPasswordOutput) GoString() string {
	return s.String()
}

// Represents the request to set user settings as an administrator.
type AdminSetUserSettingsInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminSetUserSettingsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminSetUserSettingsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminSetUserSettingsInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminSetUserSettingsInput"}
	if s.MFAOptions == nil {
		invalidParams.Add(request.NewErrParamRequired("MFAOptions"))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}
	if s.MFAOptions != nil {
		for i, v := range s.MFAOptions {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "MFAOptions", i), err.(request.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server to set user settings as an administrator.
type AdminSetUserSettingsOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AdminSetUserSettingsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminSetUserSettingsOutput) GoString() string {
	return s.String()
}

// Represents the request to update the user's attributes as an administrator.
type AdminUpdateUserAttributesInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s AdminUpdateUserAttributesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminUpdateUserAttributesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AdminUpdateUserAttributesInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AdminUpdateUserAttributesInput"}
	if s.UserAttributes == nil {
		invalidParams.Add(request.NewErrParamRequired("UserAttributes"))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}
	if s.UserAttributes != nil {
		for i, v := range s.UserAttributes {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "UserAttributes", i), err.(request.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server for the request to update user attributes
// as an administrator.
type AdminUpdateUserAttributesOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s AdminUpdateUserAttributesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AdminUpdateUserAttributesOutput) GoString() string {
	return s.String()
}

// Specifies whether the attribute is standard or custom.
type AttributeType struct {
	_ struct{} `type:"structure"`

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

	// The value of the attribute.
	Value *string `type:"string"`
}

// String returns the string representation
func (s AttributeType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AttributeType) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AttributeType) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AttributeType"}
	if s.Name == nil {
		invalidParams.Add(request.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Name", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the request to change a user password.
type ChangePasswordInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ChangePasswordInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ChangePasswordInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ChangePasswordInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ChangePasswordInput"}
	if s.PreviousPassword == nil {
		invalidParams.Add(request.NewErrParamRequired("PreviousPassword"))
	}
	if s.PreviousPassword != nil && len(*s.PreviousPassword) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("PreviousPassword", 6))
	}
	if s.ProposedPassword == nil {
		invalidParams.Add(request.NewErrParamRequired("ProposedPassword"))
	}
	if s.ProposedPassword != nil && len(*s.ProposedPassword) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("ProposedPassword", 6))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The response from the server to the change password request.
type ChangePasswordOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s ChangePasswordOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ChangePasswordOutput) GoString() string {
	return s.String()
}

// The type of code delivery details being returned from the server.
type CodeDeliveryDetailsType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s CodeDeliveryDetailsType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CodeDeliveryDetailsType) GoString() string {
	return s.String()
}

// The request representing the confirmation for a password reset.
type ConfirmForgotPasswordInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ConfirmForgotPasswordInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ConfirmForgotPasswordInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ConfirmForgotPasswordInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ConfirmForgotPasswordInput"}
	if s.ClientId == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientId"))
	}
	if s.ClientId != nil && len(*s.ClientId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientId", 1))
	}
	if s.ConfirmationCode == nil {
		invalidParams.Add(request.NewErrParamRequired("ConfirmationCode"))
	}
	if s.ConfirmationCode != nil && len(*s.ConfirmationCode) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ConfirmationCode", 1))
	}
	if s.Password == nil {
		invalidParams.Add(request.NewErrParamRequired("Password"))
	}
	if s.Password != nil && len(*s.Password) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("Password", 6))
	}
	if s.SecretHash != nil && len(*s.SecretHash) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SecretHash", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The response from the server that results from a user's request to retrieve
// a forgotten password.
type ConfirmForgotPasswordOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s ConfirmForgotPasswordOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ConfirmForgotPasswordOutput) GoString() string {
	return s.String()
}

// Represents the request to confirm registration of a user.
type ConfirmSignUpInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ConfirmSignUpInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ConfirmSignUpInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ConfirmSignUpInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ConfirmSignUpInput"}
	if s.ClientId == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientId"))
	}
	if s.ClientId != nil && len(*s.ClientId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientId", 1))
	}
	if s.ConfirmationCode == nil {
		invalidParams.Add(request.NewErrParamRequired("ConfirmationCode"))
	}
	if s.ConfirmationCode != nil && len(*s.ConfirmationCode) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ConfirmationCode", 1))
	}
	if s.SecretHash != nil && len(*s.SecretHash) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SecretHash", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server for the registration confirmation.
type ConfirmSignUpOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s ConfirmSignUpOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ConfirmSignUpOutput) GoString() string {
	return s.String()
}

// Represents the request to create a user pool client.
type CreateUserPoolClientInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s CreateUserPoolClientInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateUserPoolClientInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateUserPoolClientInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "CreateUserPoolClientInput"}
	if s.ClientName == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientName"))
	}
	if s.ClientName != nil && len(*s.ClientName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientName", 1))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server to create a user pool client.
type CreateUserPoolClientOutput struct {
	_ struct{} `type:"structure"`

	// The user pool client that was just created.
	UserPoolClient *UserPoolClientType `type:"structure"`
}

// String returns the string representation
func (s CreateUserPoolClientOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateUserPoolClientOutput) GoString() string {
	return s.String()
}

// Represents the request to create a user pool.
type CreateUserPoolInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s CreateUserPoolInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateUserPoolInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateUserPoolInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "CreateUserPoolInput"}
	if s.EmailVerificationMessage != nil && len(*s.EmailVerificationMessage) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("EmailVerificationMessage", 6))
	}
	if s.EmailVerificationSubject != nil && len(*s.EmailVerificationSubject) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("EmailVerificationSubject", 1))
	}
	if s.PoolName == nil {
		invalidParams.Add(request.NewErrParamRequired("PoolName"))
	}
	if s.PoolName != nil && len(*s.PoolName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("PoolName", 1))
	}
	if s.SmsAuthenticationMessage != nil && len(*s.SmsAuthenticationMessage) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("SmsAuthenticationMessage", 6))
	}
	if s.SmsVerificationMessage != nil && len(*s.SmsVerificationMessage) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("SmsVerificationMessage", 6))
	}
	if s.LambdaConfig != nil {
		if err := s.LambdaConfig.Validate(); err != nil {
			invalidParams.AddNested("LambdaConfig", err.(request.ErrInvalidParams))
		}
	}
	if s.Policies != nil {
		if err := s.Policies.Validate(); err != nil {
			invalidParams.AddNested("Policies", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server for the request to create a user
// pool.
type CreateUserPoolOutput struct {
	_ struct{} `type:"structure"`

	// A container for the user pool details.
	UserPool *UserPoolType `type:"structure"`
}

// String returns the string representation
func (s CreateUserPoolOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateUserPoolOutput) GoString() string {
	return s.String()
}

// Represents the request to delete user attributes.
type DeleteUserAttributesInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s DeleteUserAttributesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserAttributesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteUserAttributesInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "DeleteUserAttributesInput"}
	if s.UserAttributeNames == nil {
		invalidParams.Add(request.NewErrParamRequired("UserAttributeNames"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server to delete user attributes.
type DeleteUserAttributesOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s DeleteUserAttributesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserAttributesOutput) GoString() string {
	return s.String()
}

// Represents the request to delete a user.
type DeleteUserInput struct {
	_ struct{} `type:"structure"`

	// The access token from a request to delete a user.
	AccessToken *string `type:"string"`
}

// String returns the string representation
func (s DeleteUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserInput) GoString() string {
	return s.String()
}

type DeleteUserOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s DeleteUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserOutput) GoString() string {
	return s.String()
}

// Represents the request to delete a user pool client.
type DeleteUserPoolClientInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s DeleteUserPoolClientInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserPoolClientInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteUserPoolClientInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "DeleteUserPoolClientInput"}
	if s.ClientId == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientId"))
	}
	if s.ClientId != nil && len(*s.ClientId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientId", 1))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

type DeleteUserPoolClientOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s DeleteUserPoolClientOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserPoolClientOutput) GoString() string {
	return s.String()
}

// Represents the request to delete a user pool.
type DeleteUserPoolInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s DeleteUserPoolInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserPoolInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteUserPoolInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "DeleteUserPoolInput"}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

type DeleteUserPoolOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s DeleteUserPoolOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserPoolOutput) GoString() string {
	return s.String()
}

// Represents the request to describe a user pool client.
type DescribeUserPoolClientInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s DescribeUserPoolClientInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeUserPoolClientInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeUserPoolClientInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "DescribeUserPoolClientInput"}
	if s.ClientId == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientId"))
	}
	if s.ClientId != nil && len(*s.ClientId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientId", 1))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server from a request to describe the user
// pool client.
type DescribeUserPoolClientOutput struct {
	_ struct{} `type:"structure"`

	// The user pool client from a server response to describe the user pool client.
	UserPoolClient *UserPoolClientType `type:"structure"`
}

// String returns the string representation
func (s DescribeUserPoolClientOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeUserPoolClientOutput) GoString() string {
	return s.String()
}

// Represents the request to describe the user pool.
type DescribeUserPoolInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s DescribeUserPoolInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeUserPoolInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeUserPoolInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "DescribeUserPoolInput"}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response to describe the user pool.
type DescribeUserPoolOutput struct {
	_ struct{} `type:"structure"`

	// The container of metadata returned by the server to describe the pool.
	UserPool *UserPoolType `type:"structure"`
}

// String returns the string representation
func (s DescribeUserPoolOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeUserPoolOutput) GoString() string {
	return s.String()
}

// Represents the request to reset a user's password.
type ForgotPasswordInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ForgotPasswordInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ForgotPasswordInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ForgotPasswordInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ForgotPasswordInput"}
	if s.ClientId == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientId"))
	}
	if s.ClientId != nil && len(*s.ClientId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientId", 1))
	}
	if s.SecretHash != nil && len(*s.SecretHash) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SecretHash", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Respresents the response from the server regarding the request to reset a
// password.
type ForgotPasswordOutput struct {
	_ struct{} `type:"structure"`

	// The type of code delivery details being returned from the server.
	CodeDeliveryDetails *CodeDeliveryDetailsType `type:"structure"`
}

// String returns the string representation
func (s ForgotPasswordOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ForgotPasswordOutput) GoString() string {
	return s.String()
}

// Represents the request to get user attribute verification.
type GetUserAttributeVerificationCodeInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s GetUserAttributeVerificationCodeInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetUserAttributeVerificationCodeInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetUserAttributeVerificationCodeInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "GetUserAttributeVerificationCodeInput"}
	if s.AttributeName == nil {
		invalidParams.Add(request.NewErrParamRequired("AttributeName"))
	}
	if s.AttributeName != nil && len(*s.AttributeName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("AttributeName", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The verification code response returned by the server response to get the
// user attribute verification code.
type GetUserAttributeVerificationCodeOutput struct {
	_ struct{} `type:"structure"`

	// The code delivery details returned by the server response to get the user
	// attribute verification code.
	CodeDeliveryDetails *CodeDeliveryDetailsType `type:"structure"`
}

// String returns the string representation
func (s GetUserAttributeVerificationCodeOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetUserAttributeVerificationCodeOutput) GoString() string {
	return s.String()
}

// Represents the request to get information about the user.
type GetUserInput struct {
	_ struct{} `type:"structure"`

	// The access token returned by the server response to get information about
	// the user.
	AccessToken *string `type:"string"`
}

// String returns the string representation
func (s GetUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetUserInput) GoString() string {
	return s.String()
}

// Represents the response from the server from the request to get information
// about the user.
type GetUserOutput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s GetUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetUserOutput) GoString() string {
	return s.String()
}

// Specifies the type of configuration for AWS Lambda triggers.
type LambdaConfigType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s LambdaConfigType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s LambdaConfigType) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *LambdaConfigType) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "LambdaConfigType"}
	if s.CustomMessage != nil && len(*s.CustomMessage) < 20 {
		invalidParams.Add(request.NewErrParamMinLen("CustomMessage", 20))
	}
	if s.PostAuthentication != nil && len(*s.PostAuthentication) < 20 {
		invalidParams.Add(request.NewErrParamMinLen("PostAuthentication", 20))
	}
	if s.PostConfirmation != nil && len(*s.PostConfirmation) < 20 {
		invalidParams.Add(request.NewErrParamMinLen("PostConfirmation", 20))
	}
	if s.PreAuthentication != nil && len(*s.PreAuthentication) < 20 {
		invalidParams.Add(request.NewErrParamMinLen("PreAuthentication", 20))
	}
	if s.PreSignUp != nil && len(*s.PreSignUp) < 20 {
		invalidParams.Add(request.NewErrParamMinLen("PreSignUp", 20))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the request to list the user pool clients.
type ListUserPoolClientsInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ListUserPoolClientsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListUserPoolClientsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListUserPoolClientsInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ListUserPoolClientsInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
	}
	if s.NextToken != nil && len(*s.NextToken) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server that lists user pool clients.
type ListUserPoolClientsOutput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ListUserPoolClientsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListUserPoolClientsOutput) GoString() string {
	return s.String()
}

// Represents the request to list user pools.
type ListUserPoolsInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ListUserPoolsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListUserPoolsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListUserPoolsInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ListUserPoolsInput"}
	if s.MaxResults == nil {
		invalidParams.Add(request.NewErrParamRequired("MaxResults"))
	}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
	}
	if s.NextToken != nil && len(*s.NextToken) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response to list user pools.
type ListUserPoolsOutput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ListUserPoolsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListUserPoolsOutput) GoString() string {
	return s.String()
}

// Represents the request to list users.
type ListUsersInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ListUsersInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListUsersInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListUsersInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ListUsersInput"}
	if s.Limit != nil && *s.Limit < 1 {
		invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
	}
	if s.PaginationToken != nil && len(*s.PaginationToken) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("PaginationToken", 1))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The response from the request to list users.
type ListUsersOutput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ListUsersOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListUsersOutput) GoString() string {
	return s.String()
}

// Specifies the different settings for multi-factor authentication (MFA).
type MFAOptionType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s MFAOptionType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s MFAOptionType) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *MFAOptionType) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "MFAOptionType"}
	if s.AttributeName != nil && len(*s.AttributeName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("AttributeName", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The minimum and maximum value of an attribute that is of the number data
// type.
type NumberAttributeConstraintsType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s NumberAttributeConstraintsType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s NumberAttributeConstraintsType) GoString() string {
	return s.String()
}

// The password policy type.
type PasswordPolicyType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s PasswordPolicyType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s PasswordPolicyType) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *PasswordPolicyType) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "PasswordPolicyType"}
	if s.MinimumLength != nil && *s.MinimumLength < 6 {
		invalidParams.Add(request.NewErrParamMinValue("MinimumLength", 6))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the request to resend the confirmation code.
type ResendConfirmationCodeInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s ResendConfirmationCodeInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ResendConfirmationCodeInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ResendConfirmationCodeInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ResendConfirmationCodeInput"}
	if s.ClientId == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientId"))
	}
	if s.ClientId != nil && len(*s.ClientId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientId", 1))
	}
	if s.SecretHash != nil && len(*s.SecretHash) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SecretHash", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The response from the server when the Amazon Cognito service makes the request
// to resend a confirmation code.
type ResendConfirmationCodeOutput struct {
	_ struct{} `type:"structure"`

	// The type of code delivery details being returned from the server.
	CodeDeliveryDetails *CodeDeliveryDetailsType `type:"structure"`
}

// String returns the string representation
func (s ResendConfirmationCodeOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ResendConfirmationCodeOutput) GoString() string {
	return s.String()
}

// Contains information about the schema attribute.
type SchemaAttributeType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s SchemaAttributeType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SchemaAttributeType) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *SchemaAttributeType) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "SchemaAttributeType"}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Name", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the request to set user settings.
type SetUserSettingsInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s SetUserSettingsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SetUserSettingsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *SetUserSettingsInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "SetUserSettingsInput"}
	if s.AccessToken == nil {
		invalidParams.Add(request.NewErrParamRequired("AccessToken"))
	}
	if s.MFAOptions == nil {
		invalidParams.Add(request.NewErrParamRequired("MFAOptions"))
	}
	if s.MFAOptions != nil {
		for i, v := range s.MFAOptions {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "MFAOptions", i), err.(request.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The response from the server for a set user settings request.
type SetUserSettingsOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s SetUserSettingsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SetUserSettingsOutput) GoString() string {
	return s.String()
}

// Represents the request to register a user.
type SignUpInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s SignUpInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SignUpInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *SignUpInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "SignUpInput"}
	if s.ClientId == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientId"))
	}
	if s.ClientId != nil && len(*s.ClientId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientId", 1))
	}
	if s.Password == nil {
		invalidParams.Add(request.NewErrParamRequired("Password"))
	}
	if s.Password != nil && len(*s.Password) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("Password", 6))
	}
	if s.SecretHash != nil && len(*s.SecretHash) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SecretHash", 1))
	}
	if s.Username == nil {
		invalidParams.Add(request.NewErrParamRequired("Username"))
	}
	if s.Username != nil && len(*s.Username) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Username", 1))
	}
	if s.UserAttributes != nil {
		for i, v := range s.UserAttributes {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "UserAttributes", i), err.(request.ErrInvalidParams))
			}
		}
	}
	if s.ValidationData != nil {
		for i, v := range s.ValidationData {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "ValidationData", i), err.(request.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The response from the server for a registration request.
type SignUpOutput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s SignUpOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SignUpOutput) GoString() string {
	return s.String()
}

// The type of constraints associated with an attribute of the string type.
type StringAttributeConstraintsType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s StringAttributeConstraintsType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StringAttributeConstraintsType) GoString() string {
	return s.String()
}

// Represents the request to update user attributes.
type UpdateUserAttributesInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s UpdateUserAttributesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateUserAttributesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateUserAttributesInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "UpdateUserAttributesInput"}
	if s.UserAttributes == nil {
		invalidParams.Add(request.NewErrParamRequired("UserAttributes"))
	}
	if s.UserAttributes != nil {
		for i, v := range s.UserAttributes {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "UserAttributes", i), err.(request.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server for the request to update user attributes.
type UpdateUserAttributesOutput struct {
	_ struct{} `type:"structure"`

	// The code delivery details list from the server for the request to update
	// user attributes.
	CodeDeliveryDetailsList []*CodeDeliveryDetailsType `type:"list"`
}

// String returns the string representation
func (s UpdateUserAttributesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateUserAttributesOutput) GoString() string {
	return s.String()
}

// Represents the request to update the user pool client.
type UpdateUserPoolClientInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s UpdateUserPoolClientInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateUserPoolClientInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateUserPoolClientInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "UpdateUserPoolClientInput"}
	if s.ClientId == nil {
		invalidParams.Add(request.NewErrParamRequired("ClientId"))
	}
	if s.ClientId != nil && len(*s.ClientId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientId", 1))
	}
	if s.ClientName != nil && len(*s.ClientName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientName", 1))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server to the request to update the user
// pool client.
type UpdateUserPoolClientOutput struct {
	_ struct{} `type:"structure"`

	// The user pool client value from the response from the server when an update
	// user pool client request is made.
	UserPoolClient *UserPoolClientType `type:"structure"`
}

// String returns the string representation
func (s UpdateUserPoolClientOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateUserPoolClientOutput) GoString() string {
	return s.String()
}

// Represents the request to update the user pool.
type UpdateUserPoolInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s UpdateUserPoolInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateUserPoolInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateUserPoolInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "UpdateUserPoolInput"}
	if s.EmailVerificationMessage != nil && len(*s.EmailVerificationMessage) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("EmailVerificationMessage", 6))
	}
	if s.EmailVerificationSubject != nil && len(*s.EmailVerificationSubject) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("EmailVerificationSubject", 1))
	}
	if s.SmsAuthenticationMessage != nil && len(*s.SmsAuthenticationMessage) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("SmsAuthenticationMessage", 6))
	}
	if s.SmsVerificationMessage != nil && len(*s.SmsVerificationMessage) < 6 {
		invalidParams.Add(request.NewErrParamMinLen("SmsVerificationMessage", 6))
	}
	if s.UserPoolId == nil {
		invalidParams.Add(request.NewErrParamRequired("UserPoolId"))
	}
	if s.UserPoolId != nil && len(*s.UserPoolId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("UserPoolId", 1))
	}
	if s.LambdaConfig != nil {
		if err := s.LambdaConfig.Validate(); err != nil {
			invalidParams.AddNested("LambdaConfig", err.(request.ErrInvalidParams))
		}
	}
	if s.Policies != nil {
		if err := s.Policies.Validate(); err != nil {
			invalidParams.AddNested("Policies", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Represents the response from the server when you make a request to update
// the user pool.
type UpdateUserPoolOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s UpdateUserPoolOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateUserPoolOutput) GoString() string {
	return s.String()
}

// The description of the user poool client.
type UserPoolClientDescription struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s UserPoolClientDescription) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UserPoolClientDescription) GoString() string {
	return s.String()
}

// A user pool of the client type.
type UserPoolClientType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s UserPoolClientType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UserPoolClientType) GoString() string {
	return s.String()
}

// A user pool description.
type UserPoolDescriptionType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s UserPoolDescriptionType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UserPoolDescriptionType) GoString() string {
	return s.String()
}

// The type of policy in a user pool.
type UserPoolPolicyType struct {
	_ struct{} `type:"structure"`

	// A container with information about the user pool password policy.
	PasswordPolicy *PasswordPolicyType `type:"structure"`
}

// String returns the string representation
func (s UserPoolPolicyType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UserPoolPolicyType) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UserPoolPolicyType) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "UserPoolPolicyType"}
	if s.PasswordPolicy != nil {
		if err := s.PasswordPolicy.Validate(); err != nil {
			invalidParams.AddNested("PasswordPolicy", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// A container with information about the user pool type.
type UserPoolType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s UserPoolType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UserPoolType) GoString() string {
	return s.String()
}

// The user type.
type UserType struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s UserType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UserType) GoString() string {
	return s.String()
}

// Represents the request to verify user attributes.
type VerifyUserAttributeInput struct {
	_ struct{} `type:"structure"`

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

// String returns the string representation
func (s VerifyUserAttributeInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s VerifyUserAttributeInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *VerifyUserAttributeInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "VerifyUserAttributeInput"}
	if s.AttributeName == nil {
		invalidParams.Add(request.NewErrParamRequired("AttributeName"))
	}
	if s.AttributeName != nil && len(*s.AttributeName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("AttributeName", 1))
	}
	if s.Code == nil {
		invalidParams.Add(request.NewErrParamRequired("Code"))
	}
	if s.Code != nil && len(*s.Code) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Code", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// A container representing the response from the server from the request to
// verify user attributes.
type VerifyUserAttributeOutput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s VerifyUserAttributeOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s VerifyUserAttributeOutput) GoString() string {
	return s.String()
}

const (
	// @enum AliasAttributeType
	AliasAttributeTypePhoneNumber = "phone_number"
	// @enum AliasAttributeType
	AliasAttributeTypeEmail = "email"
	// @enum AliasAttributeType
	AliasAttributeTypePreferredUsername = "preferred_username"
)

const (
	// @enum AttributeDataType
	AttributeDataTypeString = "String"
	// @enum AttributeDataType
	AttributeDataTypeNumber = "Number"
	// @enum AttributeDataType
	AttributeDataTypeDateTime = "DateTime"
	// @enum AttributeDataType
	AttributeDataTypeBoolean = "Boolean"
)

const (
	// @enum DeliveryMediumType
	DeliveryMediumTypeSms = "SMS"
	// @enum DeliveryMediumType
	DeliveryMediumTypeEmail = "EMAIL"
)

const (
	// @enum StatusType
	StatusTypeEnabled = "Enabled"
	// @enum StatusType
	StatusTypeDisabled = "Disabled"
)

const (
	// @enum UserPoolMfaType
	UserPoolMfaTypeOff = "OFF"
	// @enum UserPoolMfaType
	UserPoolMfaTypeOn = "ON"
	// @enum UserPoolMfaType
	UserPoolMfaTypeOptional = "OPTIONAL"
)

const (
	// @enum UserStatusType
	UserStatusTypeUnconfirmed = "UNCONFIRMED"
	// @enum UserStatusType
	UserStatusTypeConfirmed = "CONFIRMED"
	// @enum UserStatusType
	UserStatusTypeArchived = "ARCHIVED"
	// @enum UserStatusType
	UserStatusTypeCompromised = "COMPROMISED"
	// @enum UserStatusType
	UserStatusTypeUnknown = "UNKNOWN"
)

const (
	// @enum VerifiedAttributeType
	VerifiedAttributeTypePhoneNumber = "phone_number"
	// @enum VerifiedAttributeType
	VerifiedAttributeTypeEmail = "email"
)