// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package lexmodelsv2

import (
	"fmt"
	"time"

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

const opBuildBotLocale = "BuildBotLocale"

// BuildBotLocaleRequest generates a "aws/request.Request" representing the
// client's request for the BuildBotLocale operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See BuildBotLocale for more information on using the BuildBotLocale
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the BuildBotLocaleRequest method.
//    req, resp := client.BuildBotLocaleRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/BuildBotLocale
func (c *LexModelsV2) BuildBotLocaleRequest(input *BuildBotLocaleInput) (req *request.Request, output *BuildBotLocaleOutput) {
	op := &request.Operation{
		Name:       opBuildBotLocale,
		HTTPMethod: "POST",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/",
	}

	if input == nil {
		input = &BuildBotLocaleInput{}
	}

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

// BuildBotLocale API operation for Amazon Lex Model Building V2.
//
// Builds a bot, its intents, and its slot types into a specific locale. A bot
// can be built into multiple locales. At runtime the locale is used to choose
// a specific build of the bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation BuildBotLocale for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/BuildBotLocale
func (c *LexModelsV2) BuildBotLocale(input *BuildBotLocaleInput) (*BuildBotLocaleOutput, error) {
	req, out := c.BuildBotLocaleRequest(input)
	return out, req.Send()
}

// BuildBotLocaleWithContext is the same as BuildBotLocale with the addition of
// the ability to pass a context and additional request options.
//
// See BuildBotLocale for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) BuildBotLocaleWithContext(ctx aws.Context, input *BuildBotLocaleInput, opts ...request.Option) (*BuildBotLocaleOutput, error) {
	req, out := c.BuildBotLocaleRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateBot = "CreateBot"

// CreateBotRequest generates a "aws/request.Request" representing the
// client's request for the CreateBot operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateBot for more information on using the CreateBot
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateBotRequest method.
//    req, resp := client.CreateBotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateBot
func (c *LexModelsV2) CreateBotRequest(input *CreateBotInput) (req *request.Request, output *CreateBotOutput) {
	op := &request.Operation{
		Name:       opCreateBot,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/",
	}

	if input == nil {
		input = &CreateBotInput{}
	}

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

// CreateBot API operation for Amazon Lex Model Building V2.
//
// Creates an Amazon Lex conversational bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateBot for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateBot
func (c *LexModelsV2) CreateBot(input *CreateBotInput) (*CreateBotOutput, error) {
	req, out := c.CreateBotRequest(input)
	return out, req.Send()
}

// CreateBotWithContext is the same as CreateBot with the addition of
// the ability to pass a context and additional request options.
//
// See CreateBot for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateBotWithContext(ctx aws.Context, input *CreateBotInput, opts ...request.Option) (*CreateBotOutput, error) {
	req, out := c.CreateBotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateBotAlias = "CreateBotAlias"

// CreateBotAliasRequest generates a "aws/request.Request" representing the
// client's request for the CreateBotAlias operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateBotAlias for more information on using the CreateBotAlias
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateBotAliasRequest method.
//    req, resp := client.CreateBotAliasRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateBotAlias
func (c *LexModelsV2) CreateBotAliasRequest(input *CreateBotAliasInput) (req *request.Request, output *CreateBotAliasOutput) {
	op := &request.Operation{
		Name:       opCreateBotAlias,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botaliases/",
	}

	if input == nil {
		input = &CreateBotAliasInput{}
	}

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

// CreateBotAlias API operation for Amazon Lex Model Building V2.
//
// Creates an alias for the specified version of a bot. Use an alias to enable
// you to change the version of a bot without updating applications that use
// the bot.
//
// For example, you can create an alias called "PROD" that your applications
// use to call the Amazon Lex bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateBotAlias for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateBotAlias
func (c *LexModelsV2) CreateBotAlias(input *CreateBotAliasInput) (*CreateBotAliasOutput, error) {
	req, out := c.CreateBotAliasRequest(input)
	return out, req.Send()
}

// CreateBotAliasWithContext is the same as CreateBotAlias with the addition of
// the ability to pass a context and additional request options.
//
// See CreateBotAlias for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateBotAliasWithContext(ctx aws.Context, input *CreateBotAliasInput, opts ...request.Option) (*CreateBotAliasOutput, error) {
	req, out := c.CreateBotAliasRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateBotLocale = "CreateBotLocale"

// CreateBotLocaleRequest generates a "aws/request.Request" representing the
// client's request for the CreateBotLocale operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateBotLocale for more information on using the CreateBotLocale
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateBotLocaleRequest method.
//    req, resp := client.CreateBotLocaleRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateBotLocale
func (c *LexModelsV2) CreateBotLocaleRequest(input *CreateBotLocaleInput) (req *request.Request, output *CreateBotLocaleOutput) {
	op := &request.Operation{
		Name:       opCreateBotLocale,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/",
	}

	if input == nil {
		input = &CreateBotLocaleInput{}
	}

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

// CreateBotLocale API operation for Amazon Lex Model Building V2.
//
// Creates a locale in the bot. The locale contains the intents and slot types
// that the bot uses in conversations with users in the specified language and
// locale. You must add a locale to a bot before you can add intents and slot
// types to the bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateBotLocale for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateBotLocale
func (c *LexModelsV2) CreateBotLocale(input *CreateBotLocaleInput) (*CreateBotLocaleOutput, error) {
	req, out := c.CreateBotLocaleRequest(input)
	return out, req.Send()
}

// CreateBotLocaleWithContext is the same as CreateBotLocale with the addition of
// the ability to pass a context and additional request options.
//
// See CreateBotLocale for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateBotLocaleWithContext(ctx aws.Context, input *CreateBotLocaleInput, opts ...request.Option) (*CreateBotLocaleOutput, error) {
	req, out := c.CreateBotLocaleRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateBotVersion = "CreateBotVersion"

// CreateBotVersionRequest generates a "aws/request.Request" representing the
// client's request for the CreateBotVersion operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateBotVersion for more information on using the CreateBotVersion
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateBotVersionRequest method.
//    req, resp := client.CreateBotVersionRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateBotVersion
func (c *LexModelsV2) CreateBotVersionRequest(input *CreateBotVersionInput) (req *request.Request, output *CreateBotVersionOutput) {
	op := &request.Operation{
		Name:       opCreateBotVersion,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/",
	}

	if input == nil {
		input = &CreateBotVersionInput{}
	}

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

// CreateBotVersion API operation for Amazon Lex Model Building V2.
//
// Creates a new version of the bot based on the DRAFT version. If the DRAFT
// version of this resource hasn't changed since you created the last version,
// Amazon Lex doesn't create a new version, it returns the last created version.
//
// When you create the first version of a bot, Amazon Lex sets the version to
// 1. Subsequent versions increment by 1.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateBotVersion for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateBotVersion
func (c *LexModelsV2) CreateBotVersion(input *CreateBotVersionInput) (*CreateBotVersionOutput, error) {
	req, out := c.CreateBotVersionRequest(input)
	return out, req.Send()
}

// CreateBotVersionWithContext is the same as CreateBotVersion with the addition of
// the ability to pass a context and additional request options.
//
// See CreateBotVersion for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateBotVersionWithContext(ctx aws.Context, input *CreateBotVersionInput, opts ...request.Option) (*CreateBotVersionOutput, error) {
	req, out := c.CreateBotVersionRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateExport = "CreateExport"

// CreateExportRequest generates a "aws/request.Request" representing the
// client's request for the CreateExport operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateExport for more information on using the CreateExport
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateExportRequest method.
//    req, resp := client.CreateExportRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateExport
func (c *LexModelsV2) CreateExportRequest(input *CreateExportInput) (req *request.Request, output *CreateExportOutput) {
	op := &request.Operation{
		Name:       opCreateExport,
		HTTPMethod: "PUT",
		HTTPPath:   "/exports/",
	}

	if input == nil {
		input = &CreateExportInput{}
	}

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

// CreateExport API operation for Amazon Lex Model Building V2.
//
// Creates a zip archive containing the contents of a bot or a bot locale. The
// archive contains a directory structure that contains JSON files that define
// the bot.
//
// You can create an archive that contains the complete definition of a bot,
// or you can specify that the archive contain only the definition of a single
// bot locale.
//
// For more information about exporting bots, and about the structure of the
// export archive, see Importing and exporting bots (https://docs.aws.amazon.com/lexv2/latest/dg/importing-exporting.html)
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateExport for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateExport
func (c *LexModelsV2) CreateExport(input *CreateExportInput) (*CreateExportOutput, error) {
	req, out := c.CreateExportRequest(input)
	return out, req.Send()
}

// CreateExportWithContext is the same as CreateExport with the addition of
// the ability to pass a context and additional request options.
//
// See CreateExport for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateExportWithContext(ctx aws.Context, input *CreateExportInput, opts ...request.Option) (*CreateExportOutput, error) {
	req, out := c.CreateExportRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateIntent = "CreateIntent"

// CreateIntentRequest generates a "aws/request.Request" representing the
// client's request for the CreateIntent operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateIntent for more information on using the CreateIntent
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateIntentRequest method.
//    req, resp := client.CreateIntentRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateIntent
func (c *LexModelsV2) CreateIntentRequest(input *CreateIntentInput) (req *request.Request, output *CreateIntentOutput) {
	op := &request.Operation{
		Name:       opCreateIntent,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/",
	}

	if input == nil {
		input = &CreateIntentInput{}
	}

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

// CreateIntent API operation for Amazon Lex Model Building V2.
//
// Creates an intent.
//
// To define the interaction between the user and your bot, you define one or
// more intents. For example, for a pizza ordering bot you would create an OrderPizza
// intent.
//
// When you create an intent, you must provide a name. You can optionally provide
// the following:
//
//    * Sample utterances. For example, "I want to order a pizza" and "Can I
//    order a pizza." You can't provide utterances for built-in intents.
//
//    * Information to be gathered. You specify slots for the information that
//    you bot requests from the user. You can specify standard slot types, such
//    as date and time, or custom slot types for your application.
//
//    * How the intent is fulfilled. You can provide a Lambda function or configure
//    the intent to return the intent information to your client application.
//    If you use a Lambda function, Amazon Lex invokes the function when all
//    of the intent information is available.
//
//    * A confirmation prompt to send to the user to confirm an intent. For
//    example, "Shall I order your pizza?"
//
//    * A conclusion statement to send to the user after the intent is fulfilled.
//    For example, "I ordered your pizza."
//
//    * A follow-up prompt that asks the user for additional activity. For example,
//    "Do you want a drink with your pizza?"
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateIntent for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateIntent
func (c *LexModelsV2) CreateIntent(input *CreateIntentInput) (*CreateIntentOutput, error) {
	req, out := c.CreateIntentRequest(input)
	return out, req.Send()
}

// CreateIntentWithContext is the same as CreateIntent with the addition of
// the ability to pass a context and additional request options.
//
// See CreateIntent for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateIntentWithContext(ctx aws.Context, input *CreateIntentInput, opts ...request.Option) (*CreateIntentOutput, error) {
	req, out := c.CreateIntentRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateResourcePolicy = "CreateResourcePolicy"

// CreateResourcePolicyRequest generates a "aws/request.Request" representing the
// client's request for the CreateResourcePolicy operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateResourcePolicy for more information on using the CreateResourcePolicy
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateResourcePolicyRequest method.
//    req, resp := client.CreateResourcePolicyRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateResourcePolicy
func (c *LexModelsV2) CreateResourcePolicyRequest(input *CreateResourcePolicyInput) (req *request.Request, output *CreateResourcePolicyOutput) {
	op := &request.Operation{
		Name:       opCreateResourcePolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/policy/{resourceArn}/",
	}

	if input == nil {
		input = &CreateResourcePolicyInput{}
	}

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

// CreateResourcePolicy API operation for Amazon Lex Model Building V2.
//
// Creates a new resource policy with the specified policy statements.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateResourcePolicy for usage and error information.
//
// Returned Error Types:
//   * ResourceNotFoundException
//
//   * ServiceQuotaExceededException
//
//   * PreconditionFailedException
//
//   * ValidationException
//
//   * InternalServerException
//
//   * ThrottlingException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateResourcePolicy
func (c *LexModelsV2) CreateResourcePolicy(input *CreateResourcePolicyInput) (*CreateResourcePolicyOutput, error) {
	req, out := c.CreateResourcePolicyRequest(input)
	return out, req.Send()
}

// CreateResourcePolicyWithContext is the same as CreateResourcePolicy with the addition of
// the ability to pass a context and additional request options.
//
// See CreateResourcePolicy for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateResourcePolicyWithContext(ctx aws.Context, input *CreateResourcePolicyInput, opts ...request.Option) (*CreateResourcePolicyOutput, error) {
	req, out := c.CreateResourcePolicyRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateResourcePolicyStatement = "CreateResourcePolicyStatement"

// CreateResourcePolicyStatementRequest generates a "aws/request.Request" representing the
// client's request for the CreateResourcePolicyStatement operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateResourcePolicyStatement for more information on using the CreateResourcePolicyStatement
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateResourcePolicyStatementRequest method.
//    req, resp := client.CreateResourcePolicyStatementRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateResourcePolicyStatement
func (c *LexModelsV2) CreateResourcePolicyStatementRequest(input *CreateResourcePolicyStatementInput) (req *request.Request, output *CreateResourcePolicyStatementOutput) {
	op := &request.Operation{
		Name:       opCreateResourcePolicyStatement,
		HTTPMethod: "POST",
		HTTPPath:   "/policy/{resourceArn}/statements/",
	}

	if input == nil {
		input = &CreateResourcePolicyStatementInput{}
	}

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

// CreateResourcePolicyStatement API operation for Amazon Lex Model Building V2.
//
// Adds a new resource policy statement to a bot or bot alias. If a resource
// policy exists, the statement is added to the current resource policy. If
// a policy doesn't exist, a new policy is created.
//
// You can't create a resource policy statement that allows cross-account access.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateResourcePolicyStatement for usage and error information.
//
// Returned Error Types:
//   * ResourceNotFoundException
//
//   * ConflictException
//
//   * ServiceQuotaExceededException
//
//   * PreconditionFailedException
//
//   * ValidationException
//
//   * InternalServerException
//
//   * ThrottlingException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateResourcePolicyStatement
func (c *LexModelsV2) CreateResourcePolicyStatement(input *CreateResourcePolicyStatementInput) (*CreateResourcePolicyStatementOutput, error) {
	req, out := c.CreateResourcePolicyStatementRequest(input)
	return out, req.Send()
}

// CreateResourcePolicyStatementWithContext is the same as CreateResourcePolicyStatement with the addition of
// the ability to pass a context and additional request options.
//
// See CreateResourcePolicyStatement for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateResourcePolicyStatementWithContext(ctx aws.Context, input *CreateResourcePolicyStatementInput, opts ...request.Option) (*CreateResourcePolicyStatementOutput, error) {
	req, out := c.CreateResourcePolicyStatementRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateSlot = "CreateSlot"

// CreateSlotRequest generates a "aws/request.Request" representing the
// client's request for the CreateSlot operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateSlot for more information on using the CreateSlot
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateSlotRequest method.
//    req, resp := client.CreateSlotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateSlot
func (c *LexModelsV2) CreateSlotRequest(input *CreateSlotInput) (req *request.Request, output *CreateSlotOutput) {
	op := &request.Operation{
		Name:       opCreateSlot,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/{intentId}/slots/",
	}

	if input == nil {
		input = &CreateSlotInput{}
	}

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

// CreateSlot API operation for Amazon Lex Model Building V2.
//
// Creates a slot in an intent. A slot is a variable needed to fulfill an intent.
// For example, an OrderPizza intent might need slots for size, crust, and number
// of pizzas. For each slot, you define one or more utterances that Amazon Lex
// uses to elicit a response from the user.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateSlot for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateSlot
func (c *LexModelsV2) CreateSlot(input *CreateSlotInput) (*CreateSlotOutput, error) {
	req, out := c.CreateSlotRequest(input)
	return out, req.Send()
}

// CreateSlotWithContext is the same as CreateSlot with the addition of
// the ability to pass a context and additional request options.
//
// See CreateSlot for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateSlotWithContext(ctx aws.Context, input *CreateSlotInput, opts ...request.Option) (*CreateSlotOutput, error) {
	req, out := c.CreateSlotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateSlotType = "CreateSlotType"

// CreateSlotTypeRequest generates a "aws/request.Request" representing the
// client's request for the CreateSlotType operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateSlotType for more information on using the CreateSlotType
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateSlotTypeRequest method.
//    req, resp := client.CreateSlotTypeRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateSlotType
func (c *LexModelsV2) CreateSlotTypeRequest(input *CreateSlotTypeInput) (req *request.Request, output *CreateSlotTypeOutput) {
	op := &request.Operation{
		Name:       opCreateSlotType,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/slottypes/",
	}

	if input == nil {
		input = &CreateSlotTypeInput{}
	}

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

// CreateSlotType API operation for Amazon Lex Model Building V2.
//
// Creates a custom slot type
//
// To create a custom slot type, specify a name for the slot type and a set
// of enumeration values, the values that a slot of this type can assume.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateSlotType for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateSlotType
func (c *LexModelsV2) CreateSlotType(input *CreateSlotTypeInput) (*CreateSlotTypeOutput, error) {
	req, out := c.CreateSlotTypeRequest(input)
	return out, req.Send()
}

// CreateSlotTypeWithContext is the same as CreateSlotType with the addition of
// the ability to pass a context and additional request options.
//
// See CreateSlotType for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateSlotTypeWithContext(ctx aws.Context, input *CreateSlotTypeInput, opts ...request.Option) (*CreateSlotTypeOutput, error) {
	req, out := c.CreateSlotTypeRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateUploadUrl = "CreateUploadUrl"

// CreateUploadUrlRequest generates a "aws/request.Request" representing the
// client's request for the CreateUploadUrl operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateUploadUrl for more information on using the CreateUploadUrl
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CreateUploadUrlRequest method.
//    req, resp := client.CreateUploadUrlRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateUploadUrl
func (c *LexModelsV2) CreateUploadUrlRequest(input *CreateUploadUrlInput) (req *request.Request, output *CreateUploadUrlOutput) {
	op := &request.Operation{
		Name:       opCreateUploadUrl,
		HTTPMethod: "POST",
		HTTPPath:   "/createuploadurl/",
	}

	if input == nil {
		input = &CreateUploadUrlInput{}
	}

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

// CreateUploadUrl API operation for Amazon Lex Model Building V2.
//
// Gets a pre-signed S3 write URL that you use to upload the zip archive when
// importing a bot or a bot locale.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation CreateUploadUrl for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/CreateUploadUrl
func (c *LexModelsV2) CreateUploadUrl(input *CreateUploadUrlInput) (*CreateUploadUrlOutput, error) {
	req, out := c.CreateUploadUrlRequest(input)
	return out, req.Send()
}

// CreateUploadUrlWithContext is the same as CreateUploadUrl with the addition of
// the ability to pass a context and additional request options.
//
// See CreateUploadUrl for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) CreateUploadUrlWithContext(ctx aws.Context, input *CreateUploadUrlInput, opts ...request.Option) (*CreateUploadUrlOutput, error) {
	req, out := c.CreateUploadUrlRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteBot = "DeleteBot"

// DeleteBotRequest generates a "aws/request.Request" representing the
// client's request for the DeleteBot operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteBot for more information on using the DeleteBot
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteBotRequest method.
//    req, resp := client.DeleteBotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteBot
func (c *LexModelsV2) DeleteBotRequest(input *DeleteBotInput) (req *request.Request, output *DeleteBotOutput) {
	op := &request.Operation{
		Name:       opDeleteBot,
		HTTPMethod: "DELETE",
		HTTPPath:   "/bots/{botId}/",
	}

	if input == nil {
		input = &DeleteBotInput{}
	}

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

// DeleteBot API operation for Amazon Lex Model Building V2.
//
// Deletes all versions of a bot, including the Draft version. To delete a specific
// version, use the DeleteBotVersion operation.
//
// When you delete a bot, all of the resources contained in the bot are also
// deleted. Deleting a bot removes all locales, intents, slot, and slot types
// defined for the bot.
//
// If a bot has an alias, the DeleteBot operation returns a ResourceInUseException
// exception. If you want to delete the bot and the alias, set the skipResourceInUseCheck
// parameter to true.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteBot for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ConflictException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteBot
func (c *LexModelsV2) DeleteBot(input *DeleteBotInput) (*DeleteBotOutput, error) {
	req, out := c.DeleteBotRequest(input)
	return out, req.Send()
}

// DeleteBotWithContext is the same as DeleteBot with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteBot for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteBotWithContext(ctx aws.Context, input *DeleteBotInput, opts ...request.Option) (*DeleteBotOutput, error) {
	req, out := c.DeleteBotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteBotAlias = "DeleteBotAlias"

// DeleteBotAliasRequest generates a "aws/request.Request" representing the
// client's request for the DeleteBotAlias operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteBotAlias for more information on using the DeleteBotAlias
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteBotAliasRequest method.
//    req, resp := client.DeleteBotAliasRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteBotAlias
func (c *LexModelsV2) DeleteBotAliasRequest(input *DeleteBotAliasInput) (req *request.Request, output *DeleteBotAliasOutput) {
	op := &request.Operation{
		Name:       opDeleteBotAlias,
		HTTPMethod: "DELETE",
		HTTPPath:   "/bots/{botId}/botaliases/{botAliasId}/",
	}

	if input == nil {
		input = &DeleteBotAliasInput{}
	}

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

// DeleteBotAlias API operation for Amazon Lex Model Building V2.
//
// Deletes the specified bot alias.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteBotAlias for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ConflictException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteBotAlias
func (c *LexModelsV2) DeleteBotAlias(input *DeleteBotAliasInput) (*DeleteBotAliasOutput, error) {
	req, out := c.DeleteBotAliasRequest(input)
	return out, req.Send()
}

// DeleteBotAliasWithContext is the same as DeleteBotAlias with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteBotAlias for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteBotAliasWithContext(ctx aws.Context, input *DeleteBotAliasInput, opts ...request.Option) (*DeleteBotAliasOutput, error) {
	req, out := c.DeleteBotAliasRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteBotLocale = "DeleteBotLocale"

// DeleteBotLocaleRequest generates a "aws/request.Request" representing the
// client's request for the DeleteBotLocale operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteBotLocale for more information on using the DeleteBotLocale
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteBotLocaleRequest method.
//    req, resp := client.DeleteBotLocaleRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteBotLocale
func (c *LexModelsV2) DeleteBotLocaleRequest(input *DeleteBotLocaleInput) (req *request.Request, output *DeleteBotLocaleOutput) {
	op := &request.Operation{
		Name:       opDeleteBotLocale,
		HTTPMethod: "DELETE",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/",
	}

	if input == nil {
		input = &DeleteBotLocaleInput{}
	}

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

// DeleteBotLocale API operation for Amazon Lex Model Building V2.
//
// Removes a locale from a bot.
//
// When you delete a locale, all intents, slots, and slot types defined for
// the locale are also deleted.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteBotLocale for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteBotLocale
func (c *LexModelsV2) DeleteBotLocale(input *DeleteBotLocaleInput) (*DeleteBotLocaleOutput, error) {
	req, out := c.DeleteBotLocaleRequest(input)
	return out, req.Send()
}

// DeleteBotLocaleWithContext is the same as DeleteBotLocale with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteBotLocale for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteBotLocaleWithContext(ctx aws.Context, input *DeleteBotLocaleInput, opts ...request.Option) (*DeleteBotLocaleOutput, error) {
	req, out := c.DeleteBotLocaleRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteBotVersion = "DeleteBotVersion"

// DeleteBotVersionRequest generates a "aws/request.Request" representing the
// client's request for the DeleteBotVersion operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteBotVersion for more information on using the DeleteBotVersion
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteBotVersionRequest method.
//    req, resp := client.DeleteBotVersionRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteBotVersion
func (c *LexModelsV2) DeleteBotVersionRequest(input *DeleteBotVersionInput) (req *request.Request, output *DeleteBotVersionOutput) {
	op := &request.Operation{
		Name:       opDeleteBotVersion,
		HTTPMethod: "DELETE",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/",
	}

	if input == nil {
		input = &DeleteBotVersionInput{}
	}

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

// DeleteBotVersion API operation for Amazon Lex Model Building V2.
//
// Deletes a specific version of a bot. To delete all version of a bot, use
// the DeleteBot operation.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteBotVersion for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ConflictException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteBotVersion
func (c *LexModelsV2) DeleteBotVersion(input *DeleteBotVersionInput) (*DeleteBotVersionOutput, error) {
	req, out := c.DeleteBotVersionRequest(input)
	return out, req.Send()
}

// DeleteBotVersionWithContext is the same as DeleteBotVersion with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteBotVersion for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteBotVersionWithContext(ctx aws.Context, input *DeleteBotVersionInput, opts ...request.Option) (*DeleteBotVersionOutput, error) {
	req, out := c.DeleteBotVersionRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteExport = "DeleteExport"

// DeleteExportRequest generates a "aws/request.Request" representing the
// client's request for the DeleteExport operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteExport for more information on using the DeleteExport
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteExportRequest method.
//    req, resp := client.DeleteExportRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteExport
func (c *LexModelsV2) DeleteExportRequest(input *DeleteExportInput) (req *request.Request, output *DeleteExportOutput) {
	op := &request.Operation{
		Name:       opDeleteExport,
		HTTPMethod: "DELETE",
		HTTPPath:   "/exports/{exportId}/",
	}

	if input == nil {
		input = &DeleteExportInput{}
	}

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

// DeleteExport API operation for Amazon Lex Model Building V2.
//
// Removes a previous export and the associated files stored in an S3 bucket.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteExport for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteExport
func (c *LexModelsV2) DeleteExport(input *DeleteExportInput) (*DeleteExportOutput, error) {
	req, out := c.DeleteExportRequest(input)
	return out, req.Send()
}

// DeleteExportWithContext is the same as DeleteExport with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteExport for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteExportWithContext(ctx aws.Context, input *DeleteExportInput, opts ...request.Option) (*DeleteExportOutput, error) {
	req, out := c.DeleteExportRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteImport = "DeleteImport"

// DeleteImportRequest generates a "aws/request.Request" representing the
// client's request for the DeleteImport operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteImport for more information on using the DeleteImport
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteImportRequest method.
//    req, resp := client.DeleteImportRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteImport
func (c *LexModelsV2) DeleteImportRequest(input *DeleteImportInput) (req *request.Request, output *DeleteImportOutput) {
	op := &request.Operation{
		Name:       opDeleteImport,
		HTTPMethod: "DELETE",
		HTTPPath:   "/imports/{importId}/",
	}

	if input == nil {
		input = &DeleteImportInput{}
	}

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

// DeleteImport API operation for Amazon Lex Model Building V2.
//
// Removes a previous import and the associated file stored in an S3 bucket.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteImport for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteImport
func (c *LexModelsV2) DeleteImport(input *DeleteImportInput) (*DeleteImportOutput, error) {
	req, out := c.DeleteImportRequest(input)
	return out, req.Send()
}

// DeleteImportWithContext is the same as DeleteImport with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteImport for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteImportWithContext(ctx aws.Context, input *DeleteImportInput, opts ...request.Option) (*DeleteImportOutput, error) {
	req, out := c.DeleteImportRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteIntent = "DeleteIntent"

// DeleteIntentRequest generates a "aws/request.Request" representing the
// client's request for the DeleteIntent operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteIntent for more information on using the DeleteIntent
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteIntentRequest method.
//    req, resp := client.DeleteIntentRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteIntent
func (c *LexModelsV2) DeleteIntentRequest(input *DeleteIntentInput) (req *request.Request, output *DeleteIntentOutput) {
	op := &request.Operation{
		Name:       opDeleteIntent,
		HTTPMethod: "DELETE",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/{intentId}/",
	}

	if input == nil {
		input = &DeleteIntentInput{}
	}

	output = &DeleteIntentOutput{}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
	return
}

// DeleteIntent API operation for Amazon Lex Model Building V2.
//
// Removes the specified intent.
//
// Deleting an intent also deletes the slots associated with the intent.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteIntent for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ConflictException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteIntent
func (c *LexModelsV2) DeleteIntent(input *DeleteIntentInput) (*DeleteIntentOutput, error) {
	req, out := c.DeleteIntentRequest(input)
	return out, req.Send()
}

// DeleteIntentWithContext is the same as DeleteIntent with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteIntent for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteIntentWithContext(ctx aws.Context, input *DeleteIntentInput, opts ...request.Option) (*DeleteIntentOutput, error) {
	req, out := c.DeleteIntentRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteResourcePolicy = "DeleteResourcePolicy"

// DeleteResourcePolicyRequest generates a "aws/request.Request" representing the
// client's request for the DeleteResourcePolicy operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteResourcePolicy for more information on using the DeleteResourcePolicy
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteResourcePolicyRequest method.
//    req, resp := client.DeleteResourcePolicyRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteResourcePolicy
func (c *LexModelsV2) DeleteResourcePolicyRequest(input *DeleteResourcePolicyInput) (req *request.Request, output *DeleteResourcePolicyOutput) {
	op := &request.Operation{
		Name:       opDeleteResourcePolicy,
		HTTPMethod: "DELETE",
		HTTPPath:   "/policy/{resourceArn}/",
	}

	if input == nil {
		input = &DeleteResourcePolicyInput{}
	}

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

// DeleteResourcePolicy API operation for Amazon Lex Model Building V2.
//
// Removes an existing policy from a bot or bot alias. If the resource doesn't
// have a policy attached, Amazon Lex returns an exception.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteResourcePolicy for usage and error information.
//
// Returned Error Types:
//   * ResourceNotFoundException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
//   * ThrottlingException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteResourcePolicy
func (c *LexModelsV2) DeleteResourcePolicy(input *DeleteResourcePolicyInput) (*DeleteResourcePolicyOutput, error) {
	req, out := c.DeleteResourcePolicyRequest(input)
	return out, req.Send()
}

// DeleteResourcePolicyWithContext is the same as DeleteResourcePolicy with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteResourcePolicy for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteResourcePolicyWithContext(ctx aws.Context, input *DeleteResourcePolicyInput, opts ...request.Option) (*DeleteResourcePolicyOutput, error) {
	req, out := c.DeleteResourcePolicyRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteResourcePolicyStatement = "DeleteResourcePolicyStatement"

// DeleteResourcePolicyStatementRequest generates a "aws/request.Request" representing the
// client's request for the DeleteResourcePolicyStatement operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteResourcePolicyStatement for more information on using the DeleteResourcePolicyStatement
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteResourcePolicyStatementRequest method.
//    req, resp := client.DeleteResourcePolicyStatementRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteResourcePolicyStatement
func (c *LexModelsV2) DeleteResourcePolicyStatementRequest(input *DeleteResourcePolicyStatementInput) (req *request.Request, output *DeleteResourcePolicyStatementOutput) {
	op := &request.Operation{
		Name:       opDeleteResourcePolicyStatement,
		HTTPMethod: "DELETE",
		HTTPPath:   "/policy/{resourceArn}/statements/{statementId}/",
	}

	if input == nil {
		input = &DeleteResourcePolicyStatementInput{}
	}

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

// DeleteResourcePolicyStatement API operation for Amazon Lex Model Building V2.
//
// Deletes a policy statement from a resource policy. If you delete the last
// statement from a policy, the policy is deleted. If you specify a statement
// ID that doesn't exist in the policy, or if the bot or bot alias doesn't have
// a policy attached, Amazon Lex returns an exception.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteResourcePolicyStatement for usage and error information.
//
// Returned Error Types:
//   * ResourceNotFoundException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
//   * ThrottlingException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteResourcePolicyStatement
func (c *LexModelsV2) DeleteResourcePolicyStatement(input *DeleteResourcePolicyStatementInput) (*DeleteResourcePolicyStatementOutput, error) {
	req, out := c.DeleteResourcePolicyStatementRequest(input)
	return out, req.Send()
}

// DeleteResourcePolicyStatementWithContext is the same as DeleteResourcePolicyStatement with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteResourcePolicyStatement for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteResourcePolicyStatementWithContext(ctx aws.Context, input *DeleteResourcePolicyStatementInput, opts ...request.Option) (*DeleteResourcePolicyStatementOutput, error) {
	req, out := c.DeleteResourcePolicyStatementRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteSlot = "DeleteSlot"

// DeleteSlotRequest generates a "aws/request.Request" representing the
// client's request for the DeleteSlot operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteSlot for more information on using the DeleteSlot
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteSlotRequest method.
//    req, resp := client.DeleteSlotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteSlot
func (c *LexModelsV2) DeleteSlotRequest(input *DeleteSlotInput) (req *request.Request, output *DeleteSlotOutput) {
	op := &request.Operation{
		Name:       opDeleteSlot,
		HTTPMethod: "DELETE",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/{intentId}/slots/{slotId}/",
	}

	if input == nil {
		input = &DeleteSlotInput{}
	}

	output = &DeleteSlotOutput{}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
	return
}

// DeleteSlot API operation for Amazon Lex Model Building V2.
//
// Deletes the specified slot from an intent.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteSlot for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ConflictException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteSlot
func (c *LexModelsV2) DeleteSlot(input *DeleteSlotInput) (*DeleteSlotOutput, error) {
	req, out := c.DeleteSlotRequest(input)
	return out, req.Send()
}

// DeleteSlotWithContext is the same as DeleteSlot with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteSlot for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteSlotWithContext(ctx aws.Context, input *DeleteSlotInput, opts ...request.Option) (*DeleteSlotOutput, error) {
	req, out := c.DeleteSlotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteSlotType = "DeleteSlotType"

// DeleteSlotTypeRequest generates a "aws/request.Request" representing the
// client's request for the DeleteSlotType operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteSlotType for more information on using the DeleteSlotType
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteSlotTypeRequest method.
//    req, resp := client.DeleteSlotTypeRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteSlotType
func (c *LexModelsV2) DeleteSlotTypeRequest(input *DeleteSlotTypeInput) (req *request.Request, output *DeleteSlotTypeOutput) {
	op := &request.Operation{
		Name:       opDeleteSlotType,
		HTTPMethod: "DELETE",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/slottypes/{slotTypeId}/",
	}

	if input == nil {
		input = &DeleteSlotTypeInput{}
	}

	output = &DeleteSlotTypeOutput{}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
	return
}

// DeleteSlotType API operation for Amazon Lex Model Building V2.
//
// Deletes a slot type from a bot locale.
//
// If a slot is using the slot type, Amazon Lex throws a ResourceInUseException
// exception. To avoid the exception, set the skipResourceInUseCheck parameter
// to true.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DeleteSlotType for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ConflictException
//
//   * PreconditionFailedException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DeleteSlotType
func (c *LexModelsV2) DeleteSlotType(input *DeleteSlotTypeInput) (*DeleteSlotTypeOutput, error) {
	req, out := c.DeleteSlotTypeRequest(input)
	return out, req.Send()
}

// DeleteSlotTypeWithContext is the same as DeleteSlotType with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteSlotType for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DeleteSlotTypeWithContext(ctx aws.Context, input *DeleteSlotTypeInput, opts ...request.Option) (*DeleteSlotTypeOutput, error) {
	req, out := c.DeleteSlotTypeRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeBot = "DescribeBot"

// DescribeBotRequest generates a "aws/request.Request" representing the
// client's request for the DescribeBot operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeBot for more information on using the DescribeBot
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeBotRequest method.
//    req, resp := client.DescribeBotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeBot
func (c *LexModelsV2) DescribeBotRequest(input *DescribeBotInput) (req *request.Request, output *DescribeBotOutput) {
	op := &request.Operation{
		Name:       opDescribeBot,
		HTTPMethod: "GET",
		HTTPPath:   "/bots/{botId}/",
	}

	if input == nil {
		input = &DescribeBotInput{}
	}

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

// DescribeBot API operation for Amazon Lex Model Building V2.
//
// Provides metadata information about a bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeBot for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeBot
func (c *LexModelsV2) DescribeBot(input *DescribeBotInput) (*DescribeBotOutput, error) {
	req, out := c.DescribeBotRequest(input)
	return out, req.Send()
}

// DescribeBotWithContext is the same as DescribeBot with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeBot for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeBotWithContext(ctx aws.Context, input *DescribeBotInput, opts ...request.Option) (*DescribeBotOutput, error) {
	req, out := c.DescribeBotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeBotAlias = "DescribeBotAlias"

// DescribeBotAliasRequest generates a "aws/request.Request" representing the
// client's request for the DescribeBotAlias operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeBotAlias for more information on using the DescribeBotAlias
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeBotAliasRequest method.
//    req, resp := client.DescribeBotAliasRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeBotAlias
func (c *LexModelsV2) DescribeBotAliasRequest(input *DescribeBotAliasInput) (req *request.Request, output *DescribeBotAliasOutput) {
	op := &request.Operation{
		Name:       opDescribeBotAlias,
		HTTPMethod: "GET",
		HTTPPath:   "/bots/{botId}/botaliases/{botAliasId}/",
	}

	if input == nil {
		input = &DescribeBotAliasInput{}
	}

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

// DescribeBotAlias API operation for Amazon Lex Model Building V2.
//
// Get information about a specific bot alias.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeBotAlias for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeBotAlias
func (c *LexModelsV2) DescribeBotAlias(input *DescribeBotAliasInput) (*DescribeBotAliasOutput, error) {
	req, out := c.DescribeBotAliasRequest(input)
	return out, req.Send()
}

// DescribeBotAliasWithContext is the same as DescribeBotAlias with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeBotAlias for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeBotAliasWithContext(ctx aws.Context, input *DescribeBotAliasInput, opts ...request.Option) (*DescribeBotAliasOutput, error) {
	req, out := c.DescribeBotAliasRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeBotLocale = "DescribeBotLocale"

// DescribeBotLocaleRequest generates a "aws/request.Request" representing the
// client's request for the DescribeBotLocale operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeBotLocale for more information on using the DescribeBotLocale
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeBotLocaleRequest method.
//    req, resp := client.DescribeBotLocaleRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeBotLocale
func (c *LexModelsV2) DescribeBotLocaleRequest(input *DescribeBotLocaleInput) (req *request.Request, output *DescribeBotLocaleOutput) {
	op := &request.Operation{
		Name:       opDescribeBotLocale,
		HTTPMethod: "GET",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/",
	}

	if input == nil {
		input = &DescribeBotLocaleInput{}
	}

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

// DescribeBotLocale API operation for Amazon Lex Model Building V2.
//
// Describes the settings that a bot has for a specific locale.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeBotLocale for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeBotLocale
func (c *LexModelsV2) DescribeBotLocale(input *DescribeBotLocaleInput) (*DescribeBotLocaleOutput, error) {
	req, out := c.DescribeBotLocaleRequest(input)
	return out, req.Send()
}

// DescribeBotLocaleWithContext is the same as DescribeBotLocale with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeBotLocale for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeBotLocaleWithContext(ctx aws.Context, input *DescribeBotLocaleInput, opts ...request.Option) (*DescribeBotLocaleOutput, error) {
	req, out := c.DescribeBotLocaleRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeBotVersion = "DescribeBotVersion"

// DescribeBotVersionRequest generates a "aws/request.Request" representing the
// client's request for the DescribeBotVersion operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeBotVersion for more information on using the DescribeBotVersion
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeBotVersionRequest method.
//    req, resp := client.DescribeBotVersionRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeBotVersion
func (c *LexModelsV2) DescribeBotVersionRequest(input *DescribeBotVersionInput) (req *request.Request, output *DescribeBotVersionOutput) {
	op := &request.Operation{
		Name:       opDescribeBotVersion,
		HTTPMethod: "GET",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/",
	}

	if input == nil {
		input = &DescribeBotVersionInput{}
	}

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

// DescribeBotVersion API operation for Amazon Lex Model Building V2.
//
// Provides metadata about a version of a bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeBotVersion for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeBotVersion
func (c *LexModelsV2) DescribeBotVersion(input *DescribeBotVersionInput) (*DescribeBotVersionOutput, error) {
	req, out := c.DescribeBotVersionRequest(input)
	return out, req.Send()
}

// DescribeBotVersionWithContext is the same as DescribeBotVersion with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeBotVersion for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeBotVersionWithContext(ctx aws.Context, input *DescribeBotVersionInput, opts ...request.Option) (*DescribeBotVersionOutput, error) {
	req, out := c.DescribeBotVersionRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeExport = "DescribeExport"

// DescribeExportRequest generates a "aws/request.Request" representing the
// client's request for the DescribeExport operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeExport for more information on using the DescribeExport
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeExportRequest method.
//    req, resp := client.DescribeExportRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeExport
func (c *LexModelsV2) DescribeExportRequest(input *DescribeExportInput) (req *request.Request, output *DescribeExportOutput) {
	op := &request.Operation{
		Name:       opDescribeExport,
		HTTPMethod: "GET",
		HTTPPath:   "/exports/{exportId}/",
	}

	if input == nil {
		input = &DescribeExportInput{}
	}

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

// DescribeExport API operation for Amazon Lex Model Building V2.
//
// Gets information about a specific export.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeExport for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeExport
func (c *LexModelsV2) DescribeExport(input *DescribeExportInput) (*DescribeExportOutput, error) {
	req, out := c.DescribeExportRequest(input)
	return out, req.Send()
}

// DescribeExportWithContext is the same as DescribeExport with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeExport for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeExportWithContext(ctx aws.Context, input *DescribeExportInput, opts ...request.Option) (*DescribeExportOutput, error) {
	req, out := c.DescribeExportRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeImport = "DescribeImport"

// DescribeImportRequest generates a "aws/request.Request" representing the
// client's request for the DescribeImport operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeImport for more information on using the DescribeImport
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeImportRequest method.
//    req, resp := client.DescribeImportRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeImport
func (c *LexModelsV2) DescribeImportRequest(input *DescribeImportInput) (req *request.Request, output *DescribeImportOutput) {
	op := &request.Operation{
		Name:       opDescribeImport,
		HTTPMethod: "GET",
		HTTPPath:   "/imports/{importId}/",
	}

	if input == nil {
		input = &DescribeImportInput{}
	}

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

// DescribeImport API operation for Amazon Lex Model Building V2.
//
// Gets information about a specific import.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeImport for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeImport
func (c *LexModelsV2) DescribeImport(input *DescribeImportInput) (*DescribeImportOutput, error) {
	req, out := c.DescribeImportRequest(input)
	return out, req.Send()
}

// DescribeImportWithContext is the same as DescribeImport with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeImport for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeImportWithContext(ctx aws.Context, input *DescribeImportInput, opts ...request.Option) (*DescribeImportOutput, error) {
	req, out := c.DescribeImportRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeIntent = "DescribeIntent"

// DescribeIntentRequest generates a "aws/request.Request" representing the
// client's request for the DescribeIntent operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeIntent for more information on using the DescribeIntent
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeIntentRequest method.
//    req, resp := client.DescribeIntentRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeIntent
func (c *LexModelsV2) DescribeIntentRequest(input *DescribeIntentInput) (req *request.Request, output *DescribeIntentOutput) {
	op := &request.Operation{
		Name:       opDescribeIntent,
		HTTPMethod: "GET",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/{intentId}/",
	}

	if input == nil {
		input = &DescribeIntentInput{}
	}

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

// DescribeIntent API operation for Amazon Lex Model Building V2.
//
// Returns metadata about an intent.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeIntent for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeIntent
func (c *LexModelsV2) DescribeIntent(input *DescribeIntentInput) (*DescribeIntentOutput, error) {
	req, out := c.DescribeIntentRequest(input)
	return out, req.Send()
}

// DescribeIntentWithContext is the same as DescribeIntent with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeIntent for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeIntentWithContext(ctx aws.Context, input *DescribeIntentInput, opts ...request.Option) (*DescribeIntentOutput, error) {
	req, out := c.DescribeIntentRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeResourcePolicy = "DescribeResourcePolicy"

// DescribeResourcePolicyRequest generates a "aws/request.Request" representing the
// client's request for the DescribeResourcePolicy operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeResourcePolicy for more information on using the DescribeResourcePolicy
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeResourcePolicyRequest method.
//    req, resp := client.DescribeResourcePolicyRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeResourcePolicy
func (c *LexModelsV2) DescribeResourcePolicyRequest(input *DescribeResourcePolicyInput) (req *request.Request, output *DescribeResourcePolicyOutput) {
	op := &request.Operation{
		Name:       opDescribeResourcePolicy,
		HTTPMethod: "GET",
		HTTPPath:   "/policy/{resourceArn}/",
	}

	if input == nil {
		input = &DescribeResourcePolicyInput{}
	}

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

// DescribeResourcePolicy API operation for Amazon Lex Model Building V2.
//
// Gets the resource policy and policy revision for a bot or bot alias.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeResourcePolicy for usage and error information.
//
// Returned Error Types:
//   * ResourceNotFoundException
//
//   * InternalServerException
//
//   * ThrottlingException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeResourcePolicy
func (c *LexModelsV2) DescribeResourcePolicy(input *DescribeResourcePolicyInput) (*DescribeResourcePolicyOutput, error) {
	req, out := c.DescribeResourcePolicyRequest(input)
	return out, req.Send()
}

// DescribeResourcePolicyWithContext is the same as DescribeResourcePolicy with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeResourcePolicy for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeResourcePolicyWithContext(ctx aws.Context, input *DescribeResourcePolicyInput, opts ...request.Option) (*DescribeResourcePolicyOutput, error) {
	req, out := c.DescribeResourcePolicyRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeSlot = "DescribeSlot"

// DescribeSlotRequest generates a "aws/request.Request" representing the
// client's request for the DescribeSlot operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeSlot for more information on using the DescribeSlot
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeSlotRequest method.
//    req, resp := client.DescribeSlotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeSlot
func (c *LexModelsV2) DescribeSlotRequest(input *DescribeSlotInput) (req *request.Request, output *DescribeSlotOutput) {
	op := &request.Operation{
		Name:       opDescribeSlot,
		HTTPMethod: "GET",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/{intentId}/slots/{slotId}/",
	}

	if input == nil {
		input = &DescribeSlotInput{}
	}

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

// DescribeSlot API operation for Amazon Lex Model Building V2.
//
// Gets metadata information about a slot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeSlot for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeSlot
func (c *LexModelsV2) DescribeSlot(input *DescribeSlotInput) (*DescribeSlotOutput, error) {
	req, out := c.DescribeSlotRequest(input)
	return out, req.Send()
}

// DescribeSlotWithContext is the same as DescribeSlot with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeSlot for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeSlotWithContext(ctx aws.Context, input *DescribeSlotInput, opts ...request.Option) (*DescribeSlotOutput, error) {
	req, out := c.DescribeSlotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeSlotType = "DescribeSlotType"

// DescribeSlotTypeRequest generates a "aws/request.Request" representing the
// client's request for the DescribeSlotType operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeSlotType for more information on using the DescribeSlotType
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DescribeSlotTypeRequest method.
//    req, resp := client.DescribeSlotTypeRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeSlotType
func (c *LexModelsV2) DescribeSlotTypeRequest(input *DescribeSlotTypeInput) (req *request.Request, output *DescribeSlotTypeOutput) {
	op := &request.Operation{
		Name:       opDescribeSlotType,
		HTTPMethod: "GET",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/slottypes/{slotTypeId}/",
	}

	if input == nil {
		input = &DescribeSlotTypeInput{}
	}

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

// DescribeSlotType API operation for Amazon Lex Model Building V2.
//
// Gets metadata information about a slot type.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation DescribeSlotType for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/DescribeSlotType
func (c *LexModelsV2) DescribeSlotType(input *DescribeSlotTypeInput) (*DescribeSlotTypeOutput, error) {
	req, out := c.DescribeSlotTypeRequest(input)
	return out, req.Send()
}

// DescribeSlotTypeWithContext is the same as DescribeSlotType with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeSlotType for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) DescribeSlotTypeWithContext(ctx aws.Context, input *DescribeSlotTypeInput, opts ...request.Option) (*DescribeSlotTypeOutput, error) {
	req, out := c.DescribeSlotTypeRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opListBotAliases = "ListBotAliases"

// ListBotAliasesRequest generates a "aws/request.Request" representing the
// client's request for the ListBotAliases operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListBotAliases for more information on using the ListBotAliases
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListBotAliasesRequest method.
//    req, resp := client.ListBotAliasesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBotAliases
func (c *LexModelsV2) ListBotAliasesRequest(input *ListBotAliasesInput) (req *request.Request, output *ListBotAliasesOutput) {
	op := &request.Operation{
		Name:       opListBotAliases,
		HTTPMethod: "POST",
		HTTPPath:   "/bots/{botId}/botaliases/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListBotAliasesInput{}
	}

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

// ListBotAliases API operation for Amazon Lex Model Building V2.
//
// Gets a list of aliases for the specified bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListBotAliases for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBotAliases
func (c *LexModelsV2) ListBotAliases(input *ListBotAliasesInput) (*ListBotAliasesOutput, error) {
	req, out := c.ListBotAliasesRequest(input)
	return out, req.Send()
}

// ListBotAliasesWithContext is the same as ListBotAliases with the addition of
// the ability to pass a context and additional request options.
//
// See ListBotAliases for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBotAliasesWithContext(ctx aws.Context, input *ListBotAliasesInput, opts ...request.Option) (*ListBotAliasesOutput, error) {
	req, out := c.ListBotAliasesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListBotAliasesPages iterates over the pages of a ListBotAliases operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListBotAliases method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListBotAliases operation.
//    pageNum := 0
//    err := client.ListBotAliasesPages(params,
//        func(page *lexmodelsv2.ListBotAliasesOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListBotAliasesPages(input *ListBotAliasesInput, fn func(*ListBotAliasesOutput, bool) bool) error {
	return c.ListBotAliasesPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListBotAliasesPagesWithContext same as ListBotAliasesPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBotAliasesPagesWithContext(ctx aws.Context, input *ListBotAliasesInput, fn func(*ListBotAliasesOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListBotAliasesInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListBotAliasesRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListBotAliasesOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListBotLocales = "ListBotLocales"

// ListBotLocalesRequest generates a "aws/request.Request" representing the
// client's request for the ListBotLocales operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListBotLocales for more information on using the ListBotLocales
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListBotLocalesRequest method.
//    req, resp := client.ListBotLocalesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBotLocales
func (c *LexModelsV2) ListBotLocalesRequest(input *ListBotLocalesInput) (req *request.Request, output *ListBotLocalesOutput) {
	op := &request.Operation{
		Name:       opListBotLocales,
		HTTPMethod: "POST",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListBotLocalesInput{}
	}

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

// ListBotLocales API operation for Amazon Lex Model Building V2.
//
// Gets a list of locales for the specified bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListBotLocales for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBotLocales
func (c *LexModelsV2) ListBotLocales(input *ListBotLocalesInput) (*ListBotLocalesOutput, error) {
	req, out := c.ListBotLocalesRequest(input)
	return out, req.Send()
}

// ListBotLocalesWithContext is the same as ListBotLocales with the addition of
// the ability to pass a context and additional request options.
//
// See ListBotLocales for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBotLocalesWithContext(ctx aws.Context, input *ListBotLocalesInput, opts ...request.Option) (*ListBotLocalesOutput, error) {
	req, out := c.ListBotLocalesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListBotLocalesPages iterates over the pages of a ListBotLocales operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListBotLocales method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListBotLocales operation.
//    pageNum := 0
//    err := client.ListBotLocalesPages(params,
//        func(page *lexmodelsv2.ListBotLocalesOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListBotLocalesPages(input *ListBotLocalesInput, fn func(*ListBotLocalesOutput, bool) bool) error {
	return c.ListBotLocalesPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListBotLocalesPagesWithContext same as ListBotLocalesPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBotLocalesPagesWithContext(ctx aws.Context, input *ListBotLocalesInput, fn func(*ListBotLocalesOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListBotLocalesInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListBotLocalesRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListBotLocalesOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListBotVersions = "ListBotVersions"

// ListBotVersionsRequest generates a "aws/request.Request" representing the
// client's request for the ListBotVersions operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListBotVersions for more information on using the ListBotVersions
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListBotVersionsRequest method.
//    req, resp := client.ListBotVersionsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBotVersions
func (c *LexModelsV2) ListBotVersionsRequest(input *ListBotVersionsInput) (req *request.Request, output *ListBotVersionsOutput) {
	op := &request.Operation{
		Name:       opListBotVersions,
		HTTPMethod: "POST",
		HTTPPath:   "/bots/{botId}/botversions/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListBotVersionsInput{}
	}

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

// ListBotVersions API operation for Amazon Lex Model Building V2.
//
// Gets information about all of the versions of a bot.
//
// The ListBotVersions operation returns a summary of each version of a bot.
// For example, if a bot has three numbered versions, the ListBotVersions operation
// returns for summaries, one for each numbered version and one for the DRAFT
// version.
//
// The ListBotVersions operation always returns at least one version, the DRAFT
// version.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListBotVersions for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBotVersions
func (c *LexModelsV2) ListBotVersions(input *ListBotVersionsInput) (*ListBotVersionsOutput, error) {
	req, out := c.ListBotVersionsRequest(input)
	return out, req.Send()
}

// ListBotVersionsWithContext is the same as ListBotVersions with the addition of
// the ability to pass a context and additional request options.
//
// See ListBotVersions for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBotVersionsWithContext(ctx aws.Context, input *ListBotVersionsInput, opts ...request.Option) (*ListBotVersionsOutput, error) {
	req, out := c.ListBotVersionsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListBotVersionsPages iterates over the pages of a ListBotVersions operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListBotVersions method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListBotVersions operation.
//    pageNum := 0
//    err := client.ListBotVersionsPages(params,
//        func(page *lexmodelsv2.ListBotVersionsOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListBotVersionsPages(input *ListBotVersionsInput, fn func(*ListBotVersionsOutput, bool) bool) error {
	return c.ListBotVersionsPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListBotVersionsPagesWithContext same as ListBotVersionsPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBotVersionsPagesWithContext(ctx aws.Context, input *ListBotVersionsInput, fn func(*ListBotVersionsOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListBotVersionsInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListBotVersionsRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListBotVersionsOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListBots = "ListBots"

// ListBotsRequest generates a "aws/request.Request" representing the
// client's request for the ListBots operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListBots for more information on using the ListBots
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListBotsRequest method.
//    req, resp := client.ListBotsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBots
func (c *LexModelsV2) ListBotsRequest(input *ListBotsInput) (req *request.Request, output *ListBotsOutput) {
	op := &request.Operation{
		Name:       opListBots,
		HTTPMethod: "POST",
		HTTPPath:   "/bots/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListBotsInput{}
	}

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

// ListBots API operation for Amazon Lex Model Building V2.
//
// Gets a list of available bots.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListBots for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBots
func (c *LexModelsV2) ListBots(input *ListBotsInput) (*ListBotsOutput, error) {
	req, out := c.ListBotsRequest(input)
	return out, req.Send()
}

// ListBotsWithContext is the same as ListBots with the addition of
// the ability to pass a context and additional request options.
//
// See ListBots for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBotsWithContext(ctx aws.Context, input *ListBotsInput, opts ...request.Option) (*ListBotsOutput, error) {
	req, out := c.ListBotsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListBotsPages iterates over the pages of a ListBots operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListBots method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListBots operation.
//    pageNum := 0
//    err := client.ListBotsPages(params,
//        func(page *lexmodelsv2.ListBotsOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListBotsPages(input *ListBotsInput, fn func(*ListBotsOutput, bool) bool) error {
	return c.ListBotsPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListBotsPagesWithContext same as ListBotsPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBotsPagesWithContext(ctx aws.Context, input *ListBotsInput, fn func(*ListBotsOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListBotsInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListBotsRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListBotsOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListBuiltInIntents = "ListBuiltInIntents"

// ListBuiltInIntentsRequest generates a "aws/request.Request" representing the
// client's request for the ListBuiltInIntents operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListBuiltInIntents for more information on using the ListBuiltInIntents
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListBuiltInIntentsRequest method.
//    req, resp := client.ListBuiltInIntentsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBuiltInIntents
func (c *LexModelsV2) ListBuiltInIntentsRequest(input *ListBuiltInIntentsInput) (req *request.Request, output *ListBuiltInIntentsOutput) {
	op := &request.Operation{
		Name:       opListBuiltInIntents,
		HTTPMethod: "POST",
		HTTPPath:   "/builtins/locales/{localeId}/intents/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListBuiltInIntentsInput{}
	}

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

// ListBuiltInIntents API operation for Amazon Lex Model Building V2.
//
// Gets a list of built-in intents provided by Amazon Lex that you can use in
// your bot.
//
// To use a built-in intent as a the base for your own intent, include the built-in
// intent signature in the parentIntentSignature parameter when you call the
// CreateIntent operation. For more information, see CreateIntent.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListBuiltInIntents for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBuiltInIntents
func (c *LexModelsV2) ListBuiltInIntents(input *ListBuiltInIntentsInput) (*ListBuiltInIntentsOutput, error) {
	req, out := c.ListBuiltInIntentsRequest(input)
	return out, req.Send()
}

// ListBuiltInIntentsWithContext is the same as ListBuiltInIntents with the addition of
// the ability to pass a context and additional request options.
//
// See ListBuiltInIntents for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBuiltInIntentsWithContext(ctx aws.Context, input *ListBuiltInIntentsInput, opts ...request.Option) (*ListBuiltInIntentsOutput, error) {
	req, out := c.ListBuiltInIntentsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListBuiltInIntentsPages iterates over the pages of a ListBuiltInIntents operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListBuiltInIntents method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListBuiltInIntents operation.
//    pageNum := 0
//    err := client.ListBuiltInIntentsPages(params,
//        func(page *lexmodelsv2.ListBuiltInIntentsOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListBuiltInIntentsPages(input *ListBuiltInIntentsInput, fn func(*ListBuiltInIntentsOutput, bool) bool) error {
	return c.ListBuiltInIntentsPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListBuiltInIntentsPagesWithContext same as ListBuiltInIntentsPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBuiltInIntentsPagesWithContext(ctx aws.Context, input *ListBuiltInIntentsInput, fn func(*ListBuiltInIntentsOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListBuiltInIntentsInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListBuiltInIntentsRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListBuiltInIntentsOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListBuiltInSlotTypes = "ListBuiltInSlotTypes"

// ListBuiltInSlotTypesRequest generates a "aws/request.Request" representing the
// client's request for the ListBuiltInSlotTypes operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListBuiltInSlotTypes for more information on using the ListBuiltInSlotTypes
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListBuiltInSlotTypesRequest method.
//    req, resp := client.ListBuiltInSlotTypesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBuiltInSlotTypes
func (c *LexModelsV2) ListBuiltInSlotTypesRequest(input *ListBuiltInSlotTypesInput) (req *request.Request, output *ListBuiltInSlotTypesOutput) {
	op := &request.Operation{
		Name:       opListBuiltInSlotTypes,
		HTTPMethod: "POST",
		HTTPPath:   "/builtins/locales/{localeId}/slottypes/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListBuiltInSlotTypesInput{}
	}

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

// ListBuiltInSlotTypes API operation for Amazon Lex Model Building V2.
//
// Gets a list of built-in slot types that meet the specified criteria.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListBuiltInSlotTypes for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListBuiltInSlotTypes
func (c *LexModelsV2) ListBuiltInSlotTypes(input *ListBuiltInSlotTypesInput) (*ListBuiltInSlotTypesOutput, error) {
	req, out := c.ListBuiltInSlotTypesRequest(input)
	return out, req.Send()
}

// ListBuiltInSlotTypesWithContext is the same as ListBuiltInSlotTypes with the addition of
// the ability to pass a context and additional request options.
//
// See ListBuiltInSlotTypes for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBuiltInSlotTypesWithContext(ctx aws.Context, input *ListBuiltInSlotTypesInput, opts ...request.Option) (*ListBuiltInSlotTypesOutput, error) {
	req, out := c.ListBuiltInSlotTypesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListBuiltInSlotTypesPages iterates over the pages of a ListBuiltInSlotTypes operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListBuiltInSlotTypes method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListBuiltInSlotTypes operation.
//    pageNum := 0
//    err := client.ListBuiltInSlotTypesPages(params,
//        func(page *lexmodelsv2.ListBuiltInSlotTypesOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListBuiltInSlotTypesPages(input *ListBuiltInSlotTypesInput, fn func(*ListBuiltInSlotTypesOutput, bool) bool) error {
	return c.ListBuiltInSlotTypesPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListBuiltInSlotTypesPagesWithContext same as ListBuiltInSlotTypesPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListBuiltInSlotTypesPagesWithContext(ctx aws.Context, input *ListBuiltInSlotTypesInput, fn func(*ListBuiltInSlotTypesOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListBuiltInSlotTypesInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListBuiltInSlotTypesRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListBuiltInSlotTypesOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListExports = "ListExports"

// ListExportsRequest generates a "aws/request.Request" representing the
// client's request for the ListExports operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListExports for more information on using the ListExports
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListExportsRequest method.
//    req, resp := client.ListExportsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListExports
func (c *LexModelsV2) ListExportsRequest(input *ListExportsInput) (req *request.Request, output *ListExportsOutput) {
	op := &request.Operation{
		Name:       opListExports,
		HTTPMethod: "POST",
		HTTPPath:   "/exports/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListExportsInput{}
	}

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

// ListExports API operation for Amazon Lex Model Building V2.
//
// Lists the exports for a bot or bot locale. Exports are kept in the list for
// 7 days.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListExports for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListExports
func (c *LexModelsV2) ListExports(input *ListExportsInput) (*ListExportsOutput, error) {
	req, out := c.ListExportsRequest(input)
	return out, req.Send()
}

// ListExportsWithContext is the same as ListExports with the addition of
// the ability to pass a context and additional request options.
//
// See ListExports for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListExportsWithContext(ctx aws.Context, input *ListExportsInput, opts ...request.Option) (*ListExportsOutput, error) {
	req, out := c.ListExportsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListExportsPages iterates over the pages of a ListExports operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListExports method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListExports operation.
//    pageNum := 0
//    err := client.ListExportsPages(params,
//        func(page *lexmodelsv2.ListExportsOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListExportsPages(input *ListExportsInput, fn func(*ListExportsOutput, bool) bool) error {
	return c.ListExportsPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListExportsPagesWithContext same as ListExportsPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListExportsPagesWithContext(ctx aws.Context, input *ListExportsInput, fn func(*ListExportsOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListExportsInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListExportsRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListExportsOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListImports = "ListImports"

// ListImportsRequest generates a "aws/request.Request" representing the
// client's request for the ListImports operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListImports for more information on using the ListImports
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListImportsRequest method.
//    req, resp := client.ListImportsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListImports
func (c *LexModelsV2) ListImportsRequest(input *ListImportsInput) (req *request.Request, output *ListImportsOutput) {
	op := &request.Operation{
		Name:       opListImports,
		HTTPMethod: "POST",
		HTTPPath:   "/imports/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListImportsInput{}
	}

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

// ListImports API operation for Amazon Lex Model Building V2.
//
// Lists the imports for a bot or bot locale. Imports are kept in the list for
// 7 days.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListImports for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListImports
func (c *LexModelsV2) ListImports(input *ListImportsInput) (*ListImportsOutput, error) {
	req, out := c.ListImportsRequest(input)
	return out, req.Send()
}

// ListImportsWithContext is the same as ListImports with the addition of
// the ability to pass a context and additional request options.
//
// See ListImports for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListImportsWithContext(ctx aws.Context, input *ListImportsInput, opts ...request.Option) (*ListImportsOutput, error) {
	req, out := c.ListImportsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListImportsPages iterates over the pages of a ListImports operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListImports method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListImports operation.
//    pageNum := 0
//    err := client.ListImportsPages(params,
//        func(page *lexmodelsv2.ListImportsOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListImportsPages(input *ListImportsInput, fn func(*ListImportsOutput, bool) bool) error {
	return c.ListImportsPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListImportsPagesWithContext same as ListImportsPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListImportsPagesWithContext(ctx aws.Context, input *ListImportsInput, fn func(*ListImportsOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListImportsInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListImportsRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListImportsOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListIntents = "ListIntents"

// ListIntentsRequest generates a "aws/request.Request" representing the
// client's request for the ListIntents operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListIntents for more information on using the ListIntents
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListIntentsRequest method.
//    req, resp := client.ListIntentsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListIntents
func (c *LexModelsV2) ListIntentsRequest(input *ListIntentsInput) (req *request.Request, output *ListIntentsOutput) {
	op := &request.Operation{
		Name:       opListIntents,
		HTTPMethod: "POST",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListIntentsInput{}
	}

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

// ListIntents API operation for Amazon Lex Model Building V2.
//
// Get a list of intents that meet the specified criteria.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListIntents for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListIntents
func (c *LexModelsV2) ListIntents(input *ListIntentsInput) (*ListIntentsOutput, error) {
	req, out := c.ListIntentsRequest(input)
	return out, req.Send()
}

// ListIntentsWithContext is the same as ListIntents with the addition of
// the ability to pass a context and additional request options.
//
// See ListIntents for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListIntentsWithContext(ctx aws.Context, input *ListIntentsInput, opts ...request.Option) (*ListIntentsOutput, error) {
	req, out := c.ListIntentsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListIntentsPages iterates over the pages of a ListIntents operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListIntents method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListIntents operation.
//    pageNum := 0
//    err := client.ListIntentsPages(params,
//        func(page *lexmodelsv2.ListIntentsOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListIntentsPages(input *ListIntentsInput, fn func(*ListIntentsOutput, bool) bool) error {
	return c.ListIntentsPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListIntentsPagesWithContext same as ListIntentsPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListIntentsPagesWithContext(ctx aws.Context, input *ListIntentsInput, fn func(*ListIntentsOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListIntentsInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListIntentsRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListIntentsOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListSlotTypes = "ListSlotTypes"

// ListSlotTypesRequest generates a "aws/request.Request" representing the
// client's request for the ListSlotTypes operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListSlotTypes for more information on using the ListSlotTypes
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListSlotTypesRequest method.
//    req, resp := client.ListSlotTypesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListSlotTypes
func (c *LexModelsV2) ListSlotTypesRequest(input *ListSlotTypesInput) (req *request.Request, output *ListSlotTypesOutput) {
	op := &request.Operation{
		Name:       opListSlotTypes,
		HTTPMethod: "POST",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/slottypes/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListSlotTypesInput{}
	}

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

// ListSlotTypes API operation for Amazon Lex Model Building V2.
//
// Gets a list of slot types that match the specified criteria.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListSlotTypes for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListSlotTypes
func (c *LexModelsV2) ListSlotTypes(input *ListSlotTypesInput) (*ListSlotTypesOutput, error) {
	req, out := c.ListSlotTypesRequest(input)
	return out, req.Send()
}

// ListSlotTypesWithContext is the same as ListSlotTypes with the addition of
// the ability to pass a context and additional request options.
//
// See ListSlotTypes for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListSlotTypesWithContext(ctx aws.Context, input *ListSlotTypesInput, opts ...request.Option) (*ListSlotTypesOutput, error) {
	req, out := c.ListSlotTypesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListSlotTypesPages iterates over the pages of a ListSlotTypes operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListSlotTypes method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListSlotTypes operation.
//    pageNum := 0
//    err := client.ListSlotTypesPages(params,
//        func(page *lexmodelsv2.ListSlotTypesOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListSlotTypesPages(input *ListSlotTypesInput, fn func(*ListSlotTypesOutput, bool) bool) error {
	return c.ListSlotTypesPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListSlotTypesPagesWithContext same as ListSlotTypesPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListSlotTypesPagesWithContext(ctx aws.Context, input *ListSlotTypesInput, fn func(*ListSlotTypesOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListSlotTypesInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListSlotTypesRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListSlotTypesOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListSlots = "ListSlots"

// ListSlotsRequest generates a "aws/request.Request" representing the
// client's request for the ListSlots operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListSlots for more information on using the ListSlots
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListSlotsRequest method.
//    req, resp := client.ListSlotsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListSlots
func (c *LexModelsV2) ListSlotsRequest(input *ListSlotsInput) (req *request.Request, output *ListSlotsOutput) {
	op := &request.Operation{
		Name:       opListSlots,
		HTTPMethod: "POST",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/{intentId}/slots/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"nextToken"},
			OutputTokens:    []string{"nextToken"},
			LimitToken:      "maxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListSlotsInput{}
	}

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

// ListSlots API operation for Amazon Lex Model Building V2.
//
// Gets a list of slots that match the specified criteria.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListSlots for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListSlots
func (c *LexModelsV2) ListSlots(input *ListSlotsInput) (*ListSlotsOutput, error) {
	req, out := c.ListSlotsRequest(input)
	return out, req.Send()
}

// ListSlotsWithContext is the same as ListSlots with the addition of
// the ability to pass a context and additional request options.
//
// See ListSlots for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListSlotsWithContext(ctx aws.Context, input *ListSlotsInput, opts ...request.Option) (*ListSlotsOutput, error) {
	req, out := c.ListSlotsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// ListSlotsPages iterates over the pages of a ListSlots operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See ListSlots method for more information on how to use this operation.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a ListSlots operation.
//    pageNum := 0
//    err := client.ListSlotsPages(params,
//        func(page *lexmodelsv2.ListSlotsOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *LexModelsV2) ListSlotsPages(input *ListSlotsInput, fn func(*ListSlotsOutput, bool) bool) error {
	return c.ListSlotsPagesWithContext(aws.BackgroundContext(), input, fn)
}

// ListSlotsPagesWithContext same as ListSlotsPages except
// it takes a Context and allows setting request options on the pages.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListSlotsPagesWithContext(ctx aws.Context, input *ListSlotsInput, fn func(*ListSlotsOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *ListSlotsInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.ListSlotsRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

	for p.Next() {
		if !fn(p.Page().(*ListSlotsOutput), !p.HasNextPage()) {
			break
		}
	}

	return p.Err()
}

const opListTagsForResource = "ListTagsForResource"

// ListTagsForResourceRequest generates a "aws/request.Request" representing the
// client's request for the ListTagsForResource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListTagsForResource for more information on using the ListTagsForResource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListTagsForResourceRequest method.
//    req, resp := client.ListTagsForResourceRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListTagsForResource
func (c *LexModelsV2) ListTagsForResourceRequest(input *ListTagsForResourceInput) (req *request.Request, output *ListTagsForResourceOutput) {
	op := &request.Operation{
		Name:       opListTagsForResource,
		HTTPMethod: "GET",
		HTTPPath:   "/tags/{resourceARN}",
	}

	if input == nil {
		input = &ListTagsForResourceInput{}
	}

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

// ListTagsForResource API operation for Amazon Lex Model Building V2.
//
// Gets a list of tags associated with a resource. Only bots, bot aliases, and
// bot channels can have tags associated with them.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation ListTagsForResource for usage and error information.
//
// Returned Error Types:
//   * InternalServerException
//
//   * ThrottlingException
//
//   * ResourceNotFoundException
//
//   * ValidationException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/ListTagsForResource
func (c *LexModelsV2) ListTagsForResource(input *ListTagsForResourceInput) (*ListTagsForResourceOutput, error) {
	req, out := c.ListTagsForResourceRequest(input)
	return out, req.Send()
}

// ListTagsForResourceWithContext is the same as ListTagsForResource with the addition of
// the ability to pass a context and additional request options.
//
// See ListTagsForResource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) ListTagsForResourceWithContext(ctx aws.Context, input *ListTagsForResourceInput, opts ...request.Option) (*ListTagsForResourceOutput, error) {
	req, out := c.ListTagsForResourceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opStartImport = "StartImport"

// StartImportRequest generates a "aws/request.Request" representing the
// client's request for the StartImport operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See StartImport for more information on using the StartImport
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the StartImportRequest method.
//    req, resp := client.StartImportRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/StartImport
func (c *LexModelsV2) StartImportRequest(input *StartImportInput) (req *request.Request, output *StartImportOutput) {
	op := &request.Operation{
		Name:       opStartImport,
		HTTPMethod: "PUT",
		HTTPPath:   "/imports/",
	}

	if input == nil {
		input = &StartImportInput{}
	}

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

// StartImport API operation for Amazon Lex Model Building V2.
//
// Starts importing a bot or bot locale from a zip archive that you uploaded
// to an S3 bucket.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation StartImport for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/StartImport
func (c *LexModelsV2) StartImport(input *StartImportInput) (*StartImportOutput, error) {
	req, out := c.StartImportRequest(input)
	return out, req.Send()
}

// StartImportWithContext is the same as StartImport with the addition of
// the ability to pass a context and additional request options.
//
// See StartImport for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) StartImportWithContext(ctx aws.Context, input *StartImportInput, opts ...request.Option) (*StartImportOutput, error) {
	req, out := c.StartImportRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opTagResource = "TagResource"

// TagResourceRequest generates a "aws/request.Request" representing the
// client's request for the TagResource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See TagResource for more information on using the TagResource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the TagResourceRequest method.
//    req, resp := client.TagResourceRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/TagResource
func (c *LexModelsV2) TagResourceRequest(input *TagResourceInput) (req *request.Request, output *TagResourceOutput) {
	op := &request.Operation{
		Name:       opTagResource,
		HTTPMethod: "POST",
		HTTPPath:   "/tags/{resourceARN}",
	}

	if input == nil {
		input = &TagResourceInput{}
	}

	output = &TagResourceOutput{}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
	return
}

// TagResource API operation for Amazon Lex Model Building V2.
//
// Adds the specified tags to the specified resource. If a tag key already exists,
// the existing value is replaced with the new value.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation TagResource for usage and error information.
//
// Returned Error Types:
//   * InternalServerException
//
//   * ThrottlingException
//
//   * ResourceNotFoundException
//
//   * ValidationException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/TagResource
func (c *LexModelsV2) TagResource(input *TagResourceInput) (*TagResourceOutput, error) {
	req, out := c.TagResourceRequest(input)
	return out, req.Send()
}

// TagResourceWithContext is the same as TagResource with the addition of
// the ability to pass a context and additional request options.
//
// See TagResource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) TagResourceWithContext(ctx aws.Context, input *TagResourceInput, opts ...request.Option) (*TagResourceOutput, error) {
	req, out := c.TagResourceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUntagResource = "UntagResource"

// UntagResourceRequest generates a "aws/request.Request" representing the
// client's request for the UntagResource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UntagResource for more information on using the UntagResource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UntagResourceRequest method.
//    req, resp := client.UntagResourceRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UntagResource
func (c *LexModelsV2) UntagResourceRequest(input *UntagResourceInput) (req *request.Request, output *UntagResourceOutput) {
	op := &request.Operation{
		Name:       opUntagResource,
		HTTPMethod: "DELETE",
		HTTPPath:   "/tags/{resourceARN}",
	}

	if input == nil {
		input = &UntagResourceInput{}
	}

	output = &UntagResourceOutput{}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
	return
}

// UntagResource API operation for Amazon Lex Model Building V2.
//
// Removes tags from a bot, bot alias, or bot channel.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UntagResource for usage and error information.
//
// Returned Error Types:
//   * InternalServerException
//
//   * ThrottlingException
//
//   * ResourceNotFoundException
//
//   * ValidationException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UntagResource
func (c *LexModelsV2) UntagResource(input *UntagResourceInput) (*UntagResourceOutput, error) {
	req, out := c.UntagResourceRequest(input)
	return out, req.Send()
}

// UntagResourceWithContext is the same as UntagResource with the addition of
// the ability to pass a context and additional request options.
//
// See UntagResource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UntagResourceWithContext(ctx aws.Context, input *UntagResourceInput, opts ...request.Option) (*UntagResourceOutput, error) {
	req, out := c.UntagResourceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateBot = "UpdateBot"

// UpdateBotRequest generates a "aws/request.Request" representing the
// client's request for the UpdateBot operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateBot for more information on using the UpdateBot
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateBotRequest method.
//    req, resp := client.UpdateBotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateBot
func (c *LexModelsV2) UpdateBotRequest(input *UpdateBotInput) (req *request.Request, output *UpdateBotOutput) {
	op := &request.Operation{
		Name:       opUpdateBot,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/",
	}

	if input == nil {
		input = &UpdateBotInput{}
	}

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

// UpdateBot API operation for Amazon Lex Model Building V2.
//
// Updates the configuration of an existing bot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UpdateBot for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateBot
func (c *LexModelsV2) UpdateBot(input *UpdateBotInput) (*UpdateBotOutput, error) {
	req, out := c.UpdateBotRequest(input)
	return out, req.Send()
}

// UpdateBotWithContext is the same as UpdateBot with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateBot for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UpdateBotWithContext(ctx aws.Context, input *UpdateBotInput, opts ...request.Option) (*UpdateBotOutput, error) {
	req, out := c.UpdateBotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateBotAlias = "UpdateBotAlias"

// UpdateBotAliasRequest generates a "aws/request.Request" representing the
// client's request for the UpdateBotAlias operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateBotAlias for more information on using the UpdateBotAlias
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateBotAliasRequest method.
//    req, resp := client.UpdateBotAliasRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateBotAlias
func (c *LexModelsV2) UpdateBotAliasRequest(input *UpdateBotAliasInput) (req *request.Request, output *UpdateBotAliasOutput) {
	op := &request.Operation{
		Name:       opUpdateBotAlias,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botaliases/{botAliasId}/",
	}

	if input == nil {
		input = &UpdateBotAliasInput{}
	}

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

// UpdateBotAlias API operation for Amazon Lex Model Building V2.
//
// Updates the configuration of an existing bot alias.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UpdateBotAlias for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateBotAlias
func (c *LexModelsV2) UpdateBotAlias(input *UpdateBotAliasInput) (*UpdateBotAliasOutput, error) {
	req, out := c.UpdateBotAliasRequest(input)
	return out, req.Send()
}

// UpdateBotAliasWithContext is the same as UpdateBotAlias with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateBotAlias for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UpdateBotAliasWithContext(ctx aws.Context, input *UpdateBotAliasInput, opts ...request.Option) (*UpdateBotAliasOutput, error) {
	req, out := c.UpdateBotAliasRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateBotLocale = "UpdateBotLocale"

// UpdateBotLocaleRequest generates a "aws/request.Request" representing the
// client's request for the UpdateBotLocale operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateBotLocale for more information on using the UpdateBotLocale
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateBotLocaleRequest method.
//    req, resp := client.UpdateBotLocaleRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateBotLocale
func (c *LexModelsV2) UpdateBotLocaleRequest(input *UpdateBotLocaleInput) (req *request.Request, output *UpdateBotLocaleOutput) {
	op := &request.Operation{
		Name:       opUpdateBotLocale,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/",
	}

	if input == nil {
		input = &UpdateBotLocaleInput{}
	}

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

// UpdateBotLocale API operation for Amazon Lex Model Building V2.
//
// Updates the settings that a bot has for a specific locale.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UpdateBotLocale for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateBotLocale
func (c *LexModelsV2) UpdateBotLocale(input *UpdateBotLocaleInput) (*UpdateBotLocaleOutput, error) {
	req, out := c.UpdateBotLocaleRequest(input)
	return out, req.Send()
}

// UpdateBotLocaleWithContext is the same as UpdateBotLocale with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateBotLocale for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UpdateBotLocaleWithContext(ctx aws.Context, input *UpdateBotLocaleInput, opts ...request.Option) (*UpdateBotLocaleOutput, error) {
	req, out := c.UpdateBotLocaleRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateExport = "UpdateExport"

// UpdateExportRequest generates a "aws/request.Request" representing the
// client's request for the UpdateExport operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateExport for more information on using the UpdateExport
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateExportRequest method.
//    req, resp := client.UpdateExportRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateExport
func (c *LexModelsV2) UpdateExportRequest(input *UpdateExportInput) (req *request.Request, output *UpdateExportOutput) {
	op := &request.Operation{
		Name:       opUpdateExport,
		HTTPMethod: "PUT",
		HTTPPath:   "/exports/{exportId}/",
	}

	if input == nil {
		input = &UpdateExportInput{}
	}

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

// UpdateExport API operation for Amazon Lex Model Building V2.
//
// Updates the password used to protect an export zip archive.
//
// The password is not required. If you don't supply a password, Amazon Lex
// generates a zip file that is not protected by a password. This is the archive
// that is available at the pre-signed S3 URL provided by the operation.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UpdateExport for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * ResourceNotFoundException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateExport
func (c *LexModelsV2) UpdateExport(input *UpdateExportInput) (*UpdateExportOutput, error) {
	req, out := c.UpdateExportRequest(input)
	return out, req.Send()
}

// UpdateExportWithContext is the same as UpdateExport with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateExport for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UpdateExportWithContext(ctx aws.Context, input *UpdateExportInput, opts ...request.Option) (*UpdateExportOutput, error) {
	req, out := c.UpdateExportRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateIntent = "UpdateIntent"

// UpdateIntentRequest generates a "aws/request.Request" representing the
// client's request for the UpdateIntent operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateIntent for more information on using the UpdateIntent
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateIntentRequest method.
//    req, resp := client.UpdateIntentRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateIntent
func (c *LexModelsV2) UpdateIntentRequest(input *UpdateIntentInput) (req *request.Request, output *UpdateIntentOutput) {
	op := &request.Operation{
		Name:       opUpdateIntent,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/{intentId}/",
	}

	if input == nil {
		input = &UpdateIntentInput{}
	}

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

// UpdateIntent API operation for Amazon Lex Model Building V2.
//
// Updates the settings for an intent.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UpdateIntent for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateIntent
func (c *LexModelsV2) UpdateIntent(input *UpdateIntentInput) (*UpdateIntentOutput, error) {
	req, out := c.UpdateIntentRequest(input)
	return out, req.Send()
}

// UpdateIntentWithContext is the same as UpdateIntent with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateIntent for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UpdateIntentWithContext(ctx aws.Context, input *UpdateIntentInput, opts ...request.Option) (*UpdateIntentOutput, error) {
	req, out := c.UpdateIntentRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateResourcePolicy = "UpdateResourcePolicy"

// UpdateResourcePolicyRequest generates a "aws/request.Request" representing the
// client's request for the UpdateResourcePolicy operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateResourcePolicy for more information on using the UpdateResourcePolicy
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateResourcePolicyRequest method.
//    req, resp := client.UpdateResourcePolicyRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateResourcePolicy
func (c *LexModelsV2) UpdateResourcePolicyRequest(input *UpdateResourcePolicyInput) (req *request.Request, output *UpdateResourcePolicyOutput) {
	op := &request.Operation{
		Name:       opUpdateResourcePolicy,
		HTTPMethod: "PUT",
		HTTPPath:   "/policy/{resourceArn}/",
	}

	if input == nil {
		input = &UpdateResourcePolicyInput{}
	}

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

// UpdateResourcePolicy API operation for Amazon Lex Model Building V2.
//
// Replaces the existing resource policy for a bot or bot alias with a new one.
// If the policy doesn't exist, Amazon Lex returns an exception.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UpdateResourcePolicy for usage and error information.
//
// Returned Error Types:
//   * ResourceNotFoundException
//
//   * ServiceQuotaExceededException
//
//   * PreconditionFailedException
//
//   * ValidationException
//
//   * InternalServerException
//
//   * ThrottlingException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateResourcePolicy
func (c *LexModelsV2) UpdateResourcePolicy(input *UpdateResourcePolicyInput) (*UpdateResourcePolicyOutput, error) {
	req, out := c.UpdateResourcePolicyRequest(input)
	return out, req.Send()
}

// UpdateResourcePolicyWithContext is the same as UpdateResourcePolicy with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateResourcePolicy for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UpdateResourcePolicyWithContext(ctx aws.Context, input *UpdateResourcePolicyInput, opts ...request.Option) (*UpdateResourcePolicyOutput, error) {
	req, out := c.UpdateResourcePolicyRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateSlot = "UpdateSlot"

// UpdateSlotRequest generates a "aws/request.Request" representing the
// client's request for the UpdateSlot operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateSlot for more information on using the UpdateSlot
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateSlotRequest method.
//    req, resp := client.UpdateSlotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateSlot
func (c *LexModelsV2) UpdateSlotRequest(input *UpdateSlotInput) (req *request.Request, output *UpdateSlotOutput) {
	op := &request.Operation{
		Name:       opUpdateSlot,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/intents/{intentId}/slots/{slotId}/",
	}

	if input == nil {
		input = &UpdateSlotInput{}
	}

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

// UpdateSlot API operation for Amazon Lex Model Building V2.
//
// Updates the settings for a slot.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UpdateSlot for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateSlot
func (c *LexModelsV2) UpdateSlot(input *UpdateSlotInput) (*UpdateSlotOutput, error) {
	req, out := c.UpdateSlotRequest(input)
	return out, req.Send()
}

// UpdateSlotWithContext is the same as UpdateSlot with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateSlot for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UpdateSlotWithContext(ctx aws.Context, input *UpdateSlotInput, opts ...request.Option) (*UpdateSlotOutput, error) {
	req, out := c.UpdateSlotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateSlotType = "UpdateSlotType"

// UpdateSlotTypeRequest generates a "aws/request.Request" representing the
// client's request for the UpdateSlotType operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateSlotType for more information on using the UpdateSlotType
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateSlotTypeRequest method.
//    req, resp := client.UpdateSlotTypeRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateSlotType
func (c *LexModelsV2) UpdateSlotTypeRequest(input *UpdateSlotTypeInput) (req *request.Request, output *UpdateSlotTypeOutput) {
	op := &request.Operation{
		Name:       opUpdateSlotType,
		HTTPMethod: "PUT",
		HTTPPath:   "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/slottypes/{slotTypeId}/",
	}

	if input == nil {
		input = &UpdateSlotTypeInput{}
	}

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

// UpdateSlotType API operation for Amazon Lex Model Building V2.
//
// Updates the configuration of an existing slot type.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Lex Model Building V2's
// API operation UpdateSlotType for usage and error information.
//
// Returned Error Types:
//   * ThrottlingException
//
//   * ServiceQuotaExceededException
//
//   * ValidationException
//
//   * PreconditionFailedException
//
//   * ConflictException
//
//   * InternalServerException
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/models.lex.v2-2020-08-07/UpdateSlotType
func (c *LexModelsV2) UpdateSlotType(input *UpdateSlotTypeInput) (*UpdateSlotTypeOutput, error) {
	req, out := c.UpdateSlotTypeRequest(input)
	return out, req.Send()
}

// UpdateSlotTypeWithContext is the same as UpdateSlotType with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateSlotType for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *LexModelsV2) UpdateSlotTypeWithContext(ctx aws.Context, input *UpdateSlotTypeInput, opts ...request.Option) (*UpdateSlotTypeOutput, error) {
	req, out := c.UpdateSlotTypeRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// The location of audio log files collected when conversation logging is enabled
// for a bot.
type AudioLogDestination struct {
	_ struct{} `type:"structure"`

	// The Amazon S3 bucket where the audio log files are stored. The IAM role specified
	// in the roleArn parameter of the CreateBot operation must have permission
	// to write to this bucket.
	//
	// S3Bucket is a required field
	S3Bucket *S3BucketLogDestination `locationName:"s3Bucket" type:"structure" required:"true"`
}

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

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

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

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

// SetS3Bucket sets the S3Bucket field's value.
func (s *AudioLogDestination) SetS3Bucket(v *S3BucketLogDestination) *AudioLogDestination {
	s.S3Bucket = v
	return s
}

// Settings for logging audio of conversations between Amazon Lex and a user.
// You specify whether to log audio and the Amazon S3 bucket where the audio
// file is stored.
type AudioLogSetting struct {
	_ struct{} `type:"structure"`

	// The location of audio log files collected when conversation logging is enabled
	// for a bot.
	//
	// Destination is a required field
	Destination *AudioLogDestination `locationName:"destination" type:"structure" required:"true"`

	// Determines whether audio logging in enabled for the bot.
	//
	// Enabled is a required field
	Enabled *bool `locationName:"enabled" type:"boolean" required:"true"`
}

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

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

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

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

// SetDestination sets the Destination field's value.
func (s *AudioLogSetting) SetDestination(v *AudioLogDestination) *AudioLogSetting {
	s.Destination = v
	return s
}

// SetEnabled sets the Enabled field's value.
func (s *AudioLogSetting) SetEnabled(v bool) *AudioLogSetting {
	s.Enabled = &v
	return s
}

// Provides a record of an event that affects a bot alias. For example, when
// the version of a bot that the alias points to changes.
type BotAliasHistoryEvent struct {
	_ struct{} `type:"structure"`

	// The version of the bot that was used in the event.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// The date and time that the event ended.
	EndDate *time.Time `locationName:"endDate" type:"timestamp"`

	// The date and time that the event started.
	StartDate *time.Time `locationName:"startDate" type:"timestamp"`
}

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

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

// SetBotVersion sets the BotVersion field's value.
func (s *BotAliasHistoryEvent) SetBotVersion(v string) *BotAliasHistoryEvent {
	s.BotVersion = &v
	return s
}

// SetEndDate sets the EndDate field's value.
func (s *BotAliasHistoryEvent) SetEndDate(v time.Time) *BotAliasHistoryEvent {
	s.EndDate = &v
	return s
}

// SetStartDate sets the StartDate field's value.
func (s *BotAliasHistoryEvent) SetStartDate(v time.Time) *BotAliasHistoryEvent {
	s.StartDate = &v
	return s
}

// Specifies settings that are unique to a locale. For example, you can use
// different Lambda function depending on the bot's locale.
type BotAliasLocaleSettings struct {
	_ struct{} `type:"structure"`

	// Specifies the Lambda function that should be used in the locale.
	CodeHookSpecification *CodeHookSpecification `locationName:"codeHookSpecification" type:"structure"`

	// Determines whether the locale is enabled for the bot. If the value is false,
	// the locale isn't available for use.
	//
	// Enabled is a required field
	Enabled *bool `locationName:"enabled" type:"boolean" required:"true"`
}

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

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

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

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

// SetCodeHookSpecification sets the CodeHookSpecification field's value.
func (s *BotAliasLocaleSettings) SetCodeHookSpecification(v *CodeHookSpecification) *BotAliasLocaleSettings {
	s.CodeHookSpecification = v
	return s
}

// SetEnabled sets the Enabled field's value.
func (s *BotAliasLocaleSettings) SetEnabled(v bool) *BotAliasLocaleSettings {
	s.Enabled = &v
	return s
}

// Summary information about bot aliases returned from the ListBotAliases operation.
type BotAliasSummary struct {
	_ struct{} `type:"structure"`

	// The unique identifier assigned to the bot alias. You can use this ID to get
	// detailed information about the alias using the DescribeBotAlias operation.
	BotAliasId *string `locationName:"botAliasId" min:"10" type:"string"`

	// The name of the bot alias.
	BotAliasName *string `locationName:"botAliasName" min:"1" type:"string"`

	// The current state of the bot alias. If the status is Available, the alias
	// is ready for use.
	BotAliasStatus *string `locationName:"botAliasStatus" type:"string" enum:"BotAliasStatus"`

	// The version of the bot that the bot alias references.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// A timestamp of the date and time that the bot alias was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description of the bot alias.
	Description *string `locationName:"description" type:"string"`

	// A timestamp of the date and time that the bot alias was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`
}

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

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

// SetBotAliasId sets the BotAliasId field's value.
func (s *BotAliasSummary) SetBotAliasId(v string) *BotAliasSummary {
	s.BotAliasId = &v
	return s
}

// SetBotAliasName sets the BotAliasName field's value.
func (s *BotAliasSummary) SetBotAliasName(v string) *BotAliasSummary {
	s.BotAliasName = &v
	return s
}

// SetBotAliasStatus sets the BotAliasStatus field's value.
func (s *BotAliasSummary) SetBotAliasStatus(v string) *BotAliasSummary {
	s.BotAliasStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *BotAliasSummary) SetBotVersion(v string) *BotAliasSummary {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *BotAliasSummary) SetCreationDateTime(v time.Time) *BotAliasSummary {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *BotAliasSummary) SetDescription(v string) *BotAliasSummary {
	s.Description = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *BotAliasSummary) SetLastUpdatedDateTime(v time.Time) *BotAliasSummary {
	s.LastUpdatedDateTime = &v
	return s
}

// Provided the identity of a the bot that was exported.
type BotExportSpecification struct {
	_ struct{} `type:"structure"`

	// The identifier of the bot assigned by Amazon Lex.
	//
	// BotId is a required field
	BotId *string `locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that was exported. This will be either DRAFT or the
	// version number.
	//
	// BotVersion is a required field
	BotVersion *string `locationName:"botVersion" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *BotExportSpecification) SetBotId(v string) *BotExportSpecification {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *BotExportSpecification) SetBotVersion(v string) *BotExportSpecification {
	s.BotVersion = &v
	return s
}

// Filters the responses returned by the ListBots operation.
type BotFilter struct {
	_ struct{} `type:"structure"`

	// The name of the field to filter the list of bots.
	//
	// Name is a required field
	Name *string `locationName:"name" type:"string" required:"true" enum:"BotFilterName"`

	// The operator to use for the filter. Specify EQ when the ListBots operation
	// should return only aliases that equal the specified value. Specify CO when
	// the ListBots operation should return aliases that contain the specified value.
	//
	// Operator is a required field
	Operator *string `locationName:"operator" type:"string" required:"true" enum:"BotFilterOperator"`

	// The value to use for filtering the list of bots.
	//
	// Values is a required field
	Values []*string `locationName:"values" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetName sets the Name field's value.
func (s *BotFilter) SetName(v string) *BotFilter {
	s.Name = &v
	return s
}

// SetOperator sets the Operator field's value.
func (s *BotFilter) SetOperator(v string) *BotFilter {
	s.Operator = &v
	return s
}

// SetValues sets the Values field's value.
func (s *BotFilter) SetValues(v []*string) *BotFilter {
	s.Values = v
	return s
}

// Provides the bot parameters required for importing a bot.
type BotImportSpecification struct {
	_ struct{} `type:"structure"`

	// The name that Amazon Lex should use for the bot.
	//
	// BotName is a required field
	BotName *string `locationName:"botName" min:"1" type:"string" required:"true"`

	// A list of tags to add to the bot. You can only add tags when you import a
	// bot. You can't use the UpdateBot operation to update tags. To update tags,
	// use the TagResource operation.
	BotTags map[string]*string `locationName:"botTags" type:"map"`

	// By default, data stored by Amazon Lex is encrypted. The DataPrivacy structure
	// provides settings that determine how Amazon Lex handles special cases of
	// securing the data for your bot.
	//
	// DataPrivacy is a required field
	DataPrivacy *DataPrivacy `locationName:"dataPrivacy" type:"structure" required:"true"`

	// The time, in seconds, that Amazon Lex should keep information about a user's
	// conversation with the bot.
	//
	// A user interaction remains active for the amount of time specified. If no
	// conversation occurs during this time, the session expires and Amazon Lex
	// deletes any data provided before the timeout.
	//
	// You can specify between 60 (1 minute) and 86,400 (24 hours) seconds.
	IdleSessionTTLInSeconds *int64 `locationName:"idleSessionTTLInSeconds" min:"60" type:"integer"`

	// The Amazon Resource Name (ARN) of the IAM role used to build and run the
	// bot.
	//
	// RoleArn is a required field
	RoleArn *string `locationName:"roleArn" min:"32" type:"string" required:"true"`

	// A list of tags to add to the test alias for a bot. You can only add tags
	// when you import a bot. You can't use the UpdateAlias operation to update
	// tags. To update tags on the test alias, use the TagResource operation.
	TestBotAliasTags map[string]*string `locationName:"testBotAliasTags" type:"map"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *BotImportSpecification) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "BotImportSpecification"}
	if s.BotName == nil {
		invalidParams.Add(request.NewErrParamRequired("BotName"))
	}
	if s.BotName != nil && len(*s.BotName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("BotName", 1))
	}
	if s.DataPrivacy == nil {
		invalidParams.Add(request.NewErrParamRequired("DataPrivacy"))
	}
	if s.IdleSessionTTLInSeconds != nil && *s.IdleSessionTTLInSeconds < 60 {
		invalidParams.Add(request.NewErrParamMinValue("IdleSessionTTLInSeconds", 60))
	}
	if s.RoleArn == nil {
		invalidParams.Add(request.NewErrParamRequired("RoleArn"))
	}
	if s.RoleArn != nil && len(*s.RoleArn) < 32 {
		invalidParams.Add(request.NewErrParamMinLen("RoleArn", 32))
	}
	if s.DataPrivacy != nil {
		if err := s.DataPrivacy.Validate(); err != nil {
			invalidParams.AddNested("DataPrivacy", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotName sets the BotName field's value.
func (s *BotImportSpecification) SetBotName(v string) *BotImportSpecification {
	s.BotName = &v
	return s
}

// SetBotTags sets the BotTags field's value.
func (s *BotImportSpecification) SetBotTags(v map[string]*string) *BotImportSpecification {
	s.BotTags = v
	return s
}

// SetDataPrivacy sets the DataPrivacy field's value.
func (s *BotImportSpecification) SetDataPrivacy(v *DataPrivacy) *BotImportSpecification {
	s.DataPrivacy = v
	return s
}

// SetIdleSessionTTLInSeconds sets the IdleSessionTTLInSeconds field's value.
func (s *BotImportSpecification) SetIdleSessionTTLInSeconds(v int64) *BotImportSpecification {
	s.IdleSessionTTLInSeconds = &v
	return s
}

// SetRoleArn sets the RoleArn field's value.
func (s *BotImportSpecification) SetRoleArn(v string) *BotImportSpecification {
	s.RoleArn = &v
	return s
}

// SetTestBotAliasTags sets the TestBotAliasTags field's value.
func (s *BotImportSpecification) SetTestBotAliasTags(v map[string]*string) *BotImportSpecification {
	s.TestBotAliasTags = v
	return s
}

// Provides the bot locale parameters required for exporting a bot locale.
type BotLocaleExportSpecification struct {
	_ struct{} `type:"structure"`

	// The identifier of the bot to create the locale for.
	//
	// BotId is a required field
	BotId *string `locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot to export.
	//
	// BotVersion is a required field
	BotVersion *string `locationName:"botVersion" min:"1" type:"string" required:"true"`

	// The identifier of the language and locale to export. The string must match
	// one of the locales in the bot.
	//
	// LocaleId is a required field
	LocaleId *string `locationName:"localeId" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *BotLocaleExportSpecification) SetBotId(v string) *BotLocaleExportSpecification {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *BotLocaleExportSpecification) SetBotVersion(v string) *BotLocaleExportSpecification {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *BotLocaleExportSpecification) SetLocaleId(v string) *BotLocaleExportSpecification {
	s.LocaleId = &v
	return s
}

// Filters responses returned by the ListBotLocales operation.
type BotLocaleFilter struct {
	_ struct{} `type:"structure"`

	// The name of the field to filter the list of bots.
	//
	// Name is a required field
	Name *string `locationName:"name" type:"string" required:"true" enum:"BotLocaleFilterName"`

	// The operator to use for the filter. Specify EQ when the ListBotLocales operation
	// should return only aliases that equal the specified value. Specify CO when
	// the ListBotLocales operation should return aliases that contain the specified
	// value.
	//
	// Operator is a required field
	Operator *string `locationName:"operator" type:"string" required:"true" enum:"BotLocaleFilterOperator"`

	// The value to use for filtering the list of bots.
	//
	// Values is a required field
	Values []*string `locationName:"values" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetName sets the Name field's value.
func (s *BotLocaleFilter) SetName(v string) *BotLocaleFilter {
	s.Name = &v
	return s
}

// SetOperator sets the Operator field's value.
func (s *BotLocaleFilter) SetOperator(v string) *BotLocaleFilter {
	s.Operator = &v
	return s
}

// SetValues sets the Values field's value.
func (s *BotLocaleFilter) SetValues(v []*string) *BotLocaleFilter {
	s.Values = v
	return s
}

// Provides information about an event that occurred affecting the bot locale.
type BotLocaleHistoryEvent struct {
	_ struct{} `type:"structure"`

	// A description of the event that occurred.
	//
	// Event is a required field
	Event *string `locationName:"event" type:"string" required:"true"`

	// A timestamp of the date and time that the event occurred.
	//
	// EventDate is a required field
	EventDate *time.Time `locationName:"eventDate" type:"timestamp" required:"true"`
}

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

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

// SetEvent sets the Event field's value.
func (s *BotLocaleHistoryEvent) SetEvent(v string) *BotLocaleHistoryEvent {
	s.Event = &v
	return s
}

// SetEventDate sets the EventDate field's value.
func (s *BotLocaleHistoryEvent) SetEventDate(v time.Time) *BotLocaleHistoryEvent {
	s.EventDate = &v
	return s
}

// Provides the bot locale parameters required for importing a bot locale.
type BotLocaleImportSpecification struct {
	_ struct{} `type:"structure"`

	// The identifier of the bot to import the locale to.
	//
	// BotId is a required field
	BotId *string `locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot to import the locale to. This can only be the DRAFT
	// version of the bot.
	//
	// BotVersion is a required field
	BotVersion *string `locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The identifier of the language and locale that the bot will be used in. The
	// string must match one of the supported locales. All of the intents, slot
	// types, and slots used in the bot must have the same locale. For more information,
	// see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `locationName:"localeId" type:"string" required:"true"`

	// Determines the threshold where Amazon Lex will insert the AMAZON.FallbackIntent,
	// AMAZON.KendraSearchIntent, or both when returning alternative intents. AMAZON.FallbackIntent
	// and AMAZON.KendraSearchIntent are only inserted if they are configured for
	// the bot.
	//
	// For example, suppose a bot is configured with the confidence threshold of
	// 0.80 and the AMAZON.FallbackIntent. Amazon Lex returns three alternative
	// intents with the following confidence scores: IntentA (0.70), IntentB (0.60),
	// IntentC (0.50). The response from the PostText operation would be:
	//
	//    * AMAZON.FallbackIntent
	//
	//    * IntentA
	//
	//    * IntentB
	//
	//    * IntentC
	NluIntentConfidenceThreshold *float64 `locationName:"nluIntentConfidenceThreshold" type:"double"`

	// Defines settings for using an Amazon Polly voice to communicate with a user.
	VoiceSettings *VoiceSettings `locationName:"voiceSettings" type:"structure"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *BotLocaleImportSpecification) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "BotLocaleImportSpecification"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion == nil {
		invalidParams.Add(request.NewErrParamRequired("BotVersion"))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.LocaleId == nil {
		invalidParams.Add(request.NewErrParamRequired("LocaleId"))
	}
	if s.VoiceSettings != nil {
		if err := s.VoiceSettings.Validate(); err != nil {
			invalidParams.AddNested("VoiceSettings", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *BotLocaleImportSpecification) SetBotId(v string) *BotLocaleImportSpecification {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *BotLocaleImportSpecification) SetBotVersion(v string) *BotLocaleImportSpecification {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *BotLocaleImportSpecification) SetLocaleId(v string) *BotLocaleImportSpecification {
	s.LocaleId = &v
	return s
}

// SetNluIntentConfidenceThreshold sets the NluIntentConfidenceThreshold field's value.
func (s *BotLocaleImportSpecification) SetNluIntentConfidenceThreshold(v float64) *BotLocaleImportSpecification {
	s.NluIntentConfidenceThreshold = &v
	return s
}

// SetVoiceSettings sets the VoiceSettings field's value.
func (s *BotLocaleImportSpecification) SetVoiceSettings(v *VoiceSettings) *BotLocaleImportSpecification {
	s.VoiceSettings = v
	return s
}

// Specifies attributes for sorting a list of bot locales.
type BotLocaleSortBy struct {
	_ struct{} `type:"structure"`

	// The bot locale attribute to sort by.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"BotLocaleSortAttribute"`

	// Specifies whether to sort the bot locales in ascending or descending order.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *BotLocaleSortBy) SetAttribute(v string) *BotLocaleSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *BotLocaleSortBy) SetOrder(v string) *BotLocaleSortBy {
	s.Order = &v
	return s
}

// Summary information about bot locales returned by the ListBotLocales operation.
type BotLocaleSummary struct {
	_ struct{} `type:"structure"`

	// The current status of the bot locale. When the status is Built the locale
	// is ready for use.
	BotLocaleStatus *string `locationName:"botLocaleStatus" type:"string" enum:"BotLocaleStatus"`

	// The description of the bot locale.
	Description *string `locationName:"description" type:"string"`

	// A timestamp of the date and time that the bot locale was last built.
	LastBuildSubmittedDateTime *time.Time `locationName:"lastBuildSubmittedDateTime" type:"timestamp"`

	// A timestamp of the date and time that the bot locale was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The language and locale of the bot locale.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The name of the bot locale.
	LocaleName *string `locationName:"localeName" type:"string"`
}

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

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

// SetBotLocaleStatus sets the BotLocaleStatus field's value.
func (s *BotLocaleSummary) SetBotLocaleStatus(v string) *BotLocaleSummary {
	s.BotLocaleStatus = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *BotLocaleSummary) SetDescription(v string) *BotLocaleSummary {
	s.Description = &v
	return s
}

// SetLastBuildSubmittedDateTime sets the LastBuildSubmittedDateTime field's value.
func (s *BotLocaleSummary) SetLastBuildSubmittedDateTime(v time.Time) *BotLocaleSummary {
	s.LastBuildSubmittedDateTime = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *BotLocaleSummary) SetLastUpdatedDateTime(v time.Time) *BotLocaleSummary {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *BotLocaleSummary) SetLocaleId(v string) *BotLocaleSummary {
	s.LocaleId = &v
	return s
}

// SetLocaleName sets the LocaleName field's value.
func (s *BotLocaleSummary) SetLocaleName(v string) *BotLocaleSummary {
	s.LocaleName = &v
	return s
}

// Specifies attributes for sorting a list of bots.
type BotSortBy struct {
	_ struct{} `type:"structure"`

	// The attribute to use to sort the list of bots.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"BotSortAttribute"`

	// The order to sort the list. You can choose ascending or descending.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *BotSortBy) SetAttribute(v string) *BotSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *BotSortBy) SetOrder(v string) *BotSortBy {
	s.Order = &v
	return s
}

// Summary information about a bot returned by the ListBots operation.
type BotSummary struct {
	_ struct{} `type:"structure"`

	// The unique identifier assigned to the bot. Use this ID to get detailed information
	// about the bot with the DescribeBot operation.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The name of the bot.
	BotName *string `locationName:"botName" min:"1" type:"string"`

	// The current status of the bot. When the status is Available the bot is ready
	// for use.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`

	// The description of the bot.
	Description *string `locationName:"description" type:"string"`

	// The date and time that the bot was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The latest numerical version in use for the bot.
	LatestBotVersion *string `locationName:"latestBotVersion" min:"1" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *BotSummary) SetBotId(v string) *BotSummary {
	s.BotId = &v
	return s
}

// SetBotName sets the BotName field's value.
func (s *BotSummary) SetBotName(v string) *BotSummary {
	s.BotName = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *BotSummary) SetBotStatus(v string) *BotSummary {
	s.BotStatus = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *BotSummary) SetDescription(v string) *BotSummary {
	s.Description = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *BotSummary) SetLastUpdatedDateTime(v time.Time) *BotSummary {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLatestBotVersion sets the LatestBotVersion field's value.
func (s *BotSummary) SetLatestBotVersion(v string) *BotSummary {
	s.LatestBotVersion = &v
	return s
}

// The version of a bot used for a bot locale.
type BotVersionLocaleDetails struct {
	_ struct{} `type:"structure"`

	// The version of a bot used for a bot locale.
	//
	// SourceBotVersion is a required field
	SourceBotVersion *string `locationName:"sourceBotVersion" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetSourceBotVersion sets the SourceBotVersion field's value.
func (s *BotVersionLocaleDetails) SetSourceBotVersion(v string) *BotVersionLocaleDetails {
	s.SourceBotVersion = &v
	return s
}

// Specifies attributes for sorting a list of bot versions.
type BotVersionSortBy struct {
	_ struct{} `type:"structure"`

	// The attribute to use to sort the list of versions.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"BotVersionSortAttribute"`

	// The order to sort the list. You can specify ascending or descending order.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *BotVersionSortBy) SetAttribute(v string) *BotVersionSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *BotVersionSortBy) SetOrder(v string) *BotVersionSortBy {
	s.Order = &v
	return s
}

// Summary information about a bot version returned by the ListBotVersions operation.
type BotVersionSummary struct {
	_ struct{} `type:"structure"`

	// The name of the bot associated with the version.
	BotName *string `locationName:"botName" min:"1" type:"string"`

	// The status of the bot. When the status is available, the version of the bot
	// is ready for use.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`

	// The numeric version of the bot, or DRAFT to indicate that this is the version
	// of the bot that can be updated..
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// A timestamp of the date and time that the version was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description of the version.
	Description *string `locationName:"description" type:"string"`
}

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

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

// SetBotName sets the BotName field's value.
func (s *BotVersionSummary) SetBotName(v string) *BotVersionSummary {
	s.BotName = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *BotVersionSummary) SetBotStatus(v string) *BotVersionSummary {
	s.BotStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *BotVersionSummary) SetBotVersion(v string) *BotVersionSummary {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *BotVersionSummary) SetCreationDateTime(v time.Time) *BotVersionSummary {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *BotVersionSummary) SetDescription(v string) *BotVersionSummary {
	s.Description = &v
	return s
}

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

	// The identifier of the bot to build. The identifier is returned in the response
	// from the operation.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot to build. This can only be the draft version of the
	// bot.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The identifier of the language and locale that the bot will be used in. The
	// string must match one of the supported locales. All of the intents, slot
	// types, and slots used in the bot must have the same locale. For more information,
	// see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *BuildBotLocaleInput) SetBotId(v string) *BuildBotLocaleInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *BuildBotLocaleInput) SetBotVersion(v string) *BuildBotLocaleInput {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *BuildBotLocaleInput) SetLocaleId(v string) *BuildBotLocaleInput {
	s.LocaleId = &v
	return s
}

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

	// The identifier of the specified bot.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The bot's build status. When the status is ReadyExpressTesting you can test
	// the bot using the utterances defined for the intents and slot types. When
	// the status is Built, the bot is ready for use and can be tested using any
	// utterance.
	BotLocaleStatus *string `locationName:"botLocaleStatus" type:"string" enum:"BotLocaleStatus"`

	// The version of the bot that was built. This is only the draft version of
	// the bot.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// A timestamp indicating the date and time that the bot was last built for
	// this locale.
	LastBuildSubmittedDateTime *time.Time `locationName:"lastBuildSubmittedDateTime" type:"timestamp"`

	// The language and locale specified of where the bot can be used.
	LocaleId *string `locationName:"localeId" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *BuildBotLocaleOutput) SetBotId(v string) *BuildBotLocaleOutput {
	s.BotId = &v
	return s
}

// SetBotLocaleStatus sets the BotLocaleStatus field's value.
func (s *BuildBotLocaleOutput) SetBotLocaleStatus(v string) *BuildBotLocaleOutput {
	s.BotLocaleStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *BuildBotLocaleOutput) SetBotVersion(v string) *BuildBotLocaleOutput {
	s.BotVersion = &v
	return s
}

// SetLastBuildSubmittedDateTime sets the LastBuildSubmittedDateTime field's value.
func (s *BuildBotLocaleOutput) SetLastBuildSubmittedDateTime(v time.Time) *BuildBotLocaleOutput {
	s.LastBuildSubmittedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *BuildBotLocaleOutput) SetLocaleId(v string) *BuildBotLocaleOutput {
	s.LocaleId = &v
	return s
}

// Specifies attributes for sorting a list of built-in intents.
type BuiltInIntentSortBy struct {
	_ struct{} `type:"structure"`

	// The attribute to use to sort the list of built-in intents.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"BuiltInIntentSortAttribute"`

	// The order to sort the list. You can specify ascending or descending order.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *BuiltInIntentSortBy) SetAttribute(v string) *BuiltInIntentSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *BuiltInIntentSortBy) SetOrder(v string) *BuiltInIntentSortBy {
	s.Order = &v
	return s
}

// Provides summary information about a built-in intent for the ListBuiltInIntents
// operation.
type BuiltInIntentSummary struct {
	_ struct{} `type:"structure"`

	// The description of the intent.
	Description *string `locationName:"description" type:"string"`

	// The signature of the built-in intent. Use this to specify the parent intent
	// of a derived intent.
	IntentSignature *string `locationName:"intentSignature" type:"string"`
}

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

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

// SetDescription sets the Description field's value.
func (s *BuiltInIntentSummary) SetDescription(v string) *BuiltInIntentSummary {
	s.Description = &v
	return s
}

// SetIntentSignature sets the IntentSignature field's value.
func (s *BuiltInIntentSummary) SetIntentSignature(v string) *BuiltInIntentSummary {
	s.IntentSignature = &v
	return s
}

// Specifies attributes for sorting a list of built-in slot types.
type BuiltInSlotTypeSortBy struct {
	_ struct{} `type:"structure"`

	// The attribute to use to sort the list of built-in intents.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"BuiltInSlotTypeSortAttribute"`

	// The order to sort the list. You can choose ascending or descending.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *BuiltInSlotTypeSortBy) SetAttribute(v string) *BuiltInSlotTypeSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *BuiltInSlotTypeSortBy) SetOrder(v string) *BuiltInSlotTypeSortBy {
	s.Order = &v
	return s
}

// Provides summary information about a built-in slot type for the ListBuiltInSlotTypes
// operation.
type BuiltInSlotTypeSummary struct {
	_ struct{} `type:"structure"`

	// The description of the built-in slot type.
	Description *string `locationName:"description" type:"string"`

	// The signature of the built-in slot type. Use this to specify the parent slot
	// type of a derived slot type.
	SlotTypeSignature *string `locationName:"slotTypeSignature" type:"string"`
}

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

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

// SetDescription sets the Description field's value.
func (s *BuiltInSlotTypeSummary) SetDescription(v string) *BuiltInSlotTypeSummary {
	s.Description = &v
	return s
}

// SetSlotTypeSignature sets the SlotTypeSignature field's value.
func (s *BuiltInSlotTypeSummary) SetSlotTypeSignature(v string) *BuiltInSlotTypeSummary {
	s.SlotTypeSignature = &v
	return s
}

// Describes a button to use on a response card used to gather slot values from
// a user.
type Button struct {
	_ struct{} `type:"structure"`

	// The text that appears on the button. Use this to tell the user what value
	// is returned when they choose this button.
	//
	// Text is a required field
	Text *string `locationName:"text" min:"1" type:"string" required:"true"`

	// The value returned to Amazon Lex when the user chooses this button. This
	// must be one of the slot values configured for the slot.
	//
	// Value is a required field
	Value *string `locationName:"value" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetText sets the Text field's value.
func (s *Button) SetText(v string) *Button {
	s.Text = &v
	return s
}

// SetValue sets the Value field's value.
func (s *Button) SetValue(v string) *Button {
	s.Value = &v
	return s
}

// The Amazon CloudWatch Logs log group where the text and metadata logs are
// delivered. The log group must exist before you enable logging.
type CloudWatchLogGroupLogDestination struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the log group where text and metadata logs
	// are delivered.
	//
	// CloudWatchLogGroupArn is a required field
	CloudWatchLogGroupArn *string `locationName:"cloudWatchLogGroupArn" min:"1" type:"string" required:"true"`

	// The prefix of the log stream name within the log group that you specified
	//
	// LogPrefix is a required field
	LogPrefix *string `locationName:"logPrefix" type:"string" required:"true"`
}

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

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

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

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

// SetCloudWatchLogGroupArn sets the CloudWatchLogGroupArn field's value.
func (s *CloudWatchLogGroupLogDestination) SetCloudWatchLogGroupArn(v string) *CloudWatchLogGroupLogDestination {
	s.CloudWatchLogGroupArn = &v
	return s
}

// SetLogPrefix sets the LogPrefix field's value.
func (s *CloudWatchLogGroupLogDestination) SetLogPrefix(v string) *CloudWatchLogGroupLogDestination {
	s.LogPrefix = &v
	return s
}

// Contains information about code hooks that Amazon Lex calls during a conversation.
type CodeHookSpecification struct {
	_ struct{} `type:"structure"`

	// Specifies a Lambda function that verifies requests to a bot or fulfilles
	// the user's request to a bot.
	//
	// LambdaCodeHook is a required field
	LambdaCodeHook *LambdaCodeHook `locationName:"lambdaCodeHook" type:"structure" required:"true"`
}

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

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

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

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

// SetLambdaCodeHook sets the LambdaCodeHook field's value.
func (s *CodeHookSpecification) SetLambdaCodeHook(v *LambdaCodeHook) *CodeHookSpecification {
	s.LambdaCodeHook = v
	return s
}

type ConflictException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

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

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

func newErrorConflictException(v protocol.ResponseMetadata) error {
	return &ConflictException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *ConflictException) Code() string {
	return "ConflictException"
}

// Message returns the exception's message.
func (s *ConflictException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ConflictException) OrigErr() error {
	return nil
}

func (s *ConflictException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *ConflictException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *ConflictException) RequestID() string {
	return s.RespMetadata.RequestID
}

// Configures conversation logging that saves audio, text, and metadata for
// the conversations with your users.
type ConversationLogSettings struct {
	_ struct{} `type:"structure"`

	// The Amazon S3 settings for logging audio to an S3 bucket.
	AudioLogSettings []*AudioLogSetting `locationName:"audioLogSettings" min:"1" type:"list"`

	// The Amazon CloudWatch Logs settings for logging text and metadata.
	TextLogSettings []*TextLogSetting `locationName:"textLogSettings" min:"1" type:"list"`
}

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

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

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

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

// SetAudioLogSettings sets the AudioLogSettings field's value.
func (s *ConversationLogSettings) SetAudioLogSettings(v []*AudioLogSetting) *ConversationLogSettings {
	s.AudioLogSettings = v
	return s
}

// SetTextLogSettings sets the TextLogSettings field's value.
func (s *ConversationLogSettings) SetTextLogSettings(v []*TextLogSetting) *ConversationLogSettings {
	s.TextLogSettings = v
	return s
}

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

	// Maps configuration information to a specific locale. You can use this parameter
	// to specify a specific Lambda function to run different functions in different
	// locales.
	BotAliasLocaleSettings map[string]*BotAliasLocaleSettings `locationName:"botAliasLocaleSettings" min:"1" type:"map"`

	// The alias to create. The name must be unique for the bot.
	//
	// BotAliasName is a required field
	BotAliasName *string `locationName:"botAliasName" min:"1" type:"string" required:"true"`

	// The unique identifier of the bot that the alias applies to.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that this alias points to. You can use the operation
	// to change the bot version associated with the alias.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// Specifies whether Amazon Lex logs text and audio for a conversation with
	// the bot. When you enable conversation logs, text logs store text input, transcripts
	// of audio input, and associated metadata in Amazon CloudWatch Logs. Audio
	// logs store audio input in Amazon S3.
	ConversationLogSettings *ConversationLogSettings `locationName:"conversationLogSettings" type:"structure"`

	// A description of the alias. Use this description to help identify the alias.
	Description *string `locationName:"description" type:"string"`

	// Determines whether Amazon Lex will use Amazon Comprehend to detect the sentiment
	// of user utterances.
	SentimentAnalysisSettings *SentimentAnalysisSettings `locationName:"sentimentAnalysisSettings" type:"structure"`

	// A list of tags to add to the bot alias. You can only add tags when you create
	// an alias, you can't use the UpdateBotAlias operation to update the tags on
	// a bot alias. To update tags, use the TagResource operation.
	Tags map[string]*string `locationName:"tags" type:"map"`
}

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

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

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

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

// SetBotAliasLocaleSettings sets the BotAliasLocaleSettings field's value.
func (s *CreateBotAliasInput) SetBotAliasLocaleSettings(v map[string]*BotAliasLocaleSettings) *CreateBotAliasInput {
	s.BotAliasLocaleSettings = v
	return s
}

// SetBotAliasName sets the BotAliasName field's value.
func (s *CreateBotAliasInput) SetBotAliasName(v string) *CreateBotAliasInput {
	s.BotAliasName = &v
	return s
}

// SetBotId sets the BotId field's value.
func (s *CreateBotAliasInput) SetBotId(v string) *CreateBotAliasInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateBotAliasInput) SetBotVersion(v string) *CreateBotAliasInput {
	s.BotVersion = &v
	return s
}

// SetConversationLogSettings sets the ConversationLogSettings field's value.
func (s *CreateBotAliasInput) SetConversationLogSettings(v *ConversationLogSettings) *CreateBotAliasInput {
	s.ConversationLogSettings = v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateBotAliasInput) SetDescription(v string) *CreateBotAliasInput {
	s.Description = &v
	return s
}

// SetSentimentAnalysisSettings sets the SentimentAnalysisSettings field's value.
func (s *CreateBotAliasInput) SetSentimentAnalysisSettings(v *SentimentAnalysisSettings) *CreateBotAliasInput {
	s.SentimentAnalysisSettings = v
	return s
}

// SetTags sets the Tags field's value.
func (s *CreateBotAliasInput) SetTags(v map[string]*string) *CreateBotAliasInput {
	s.Tags = v
	return s
}

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

	// The unique identifier of the bot alias.
	BotAliasId *string `locationName:"botAliasId" min:"10" type:"string"`

	// Configuration information for a specific locale.
	BotAliasLocaleSettings map[string]*BotAliasLocaleSettings `locationName:"botAliasLocaleSettings" min:"1" type:"map"`

	// The name specified for the bot alias.
	BotAliasName *string `locationName:"botAliasName" min:"1" type:"string"`

	// The current status of the alias. The alias is first put into the Creating
	// state. When the alias is ready to be used, it is put into the Available state.
	// You can use the DescribeBotAlias operation to get the current state of an
	// alias.
	BotAliasStatus *string `locationName:"botAliasStatus" type:"string" enum:"BotAliasStatus"`

	// The unique identifier of the bot that this alias applies to.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot associated with this alias.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// The conversation log settings specified for the alias.
	ConversationLogSettings *ConversationLogSettings `locationName:"conversationLogSettings" type:"structure"`

	// A Unix timestamp indicating the date and time that the bot alias was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description specified for the bot alias.
	Description *string `locationName:"description" type:"string"`

	// Determines whether Amazon Lex will use Amazon Comprehend to detect the sentiment
	// of user utterances.
	SentimentAnalysisSettings *SentimentAnalysisSettings `locationName:"sentimentAnalysisSettings" type:"structure"`

	// A list of tags associated with the bot alias.
	Tags map[string]*string `locationName:"tags" type:"map"`
}

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

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

// SetBotAliasId sets the BotAliasId field's value.
func (s *CreateBotAliasOutput) SetBotAliasId(v string) *CreateBotAliasOutput {
	s.BotAliasId = &v
	return s
}

// SetBotAliasLocaleSettings sets the BotAliasLocaleSettings field's value.
func (s *CreateBotAliasOutput) SetBotAliasLocaleSettings(v map[string]*BotAliasLocaleSettings) *CreateBotAliasOutput {
	s.BotAliasLocaleSettings = v
	return s
}

// SetBotAliasName sets the BotAliasName field's value.
func (s *CreateBotAliasOutput) SetBotAliasName(v string) *CreateBotAliasOutput {
	s.BotAliasName = &v
	return s
}

// SetBotAliasStatus sets the BotAliasStatus field's value.
func (s *CreateBotAliasOutput) SetBotAliasStatus(v string) *CreateBotAliasOutput {
	s.BotAliasStatus = &v
	return s
}

// SetBotId sets the BotId field's value.
func (s *CreateBotAliasOutput) SetBotId(v string) *CreateBotAliasOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateBotAliasOutput) SetBotVersion(v string) *CreateBotAliasOutput {
	s.BotVersion = &v
	return s
}

// SetConversationLogSettings sets the ConversationLogSettings field's value.
func (s *CreateBotAliasOutput) SetConversationLogSettings(v *ConversationLogSettings) *CreateBotAliasOutput {
	s.ConversationLogSettings = v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *CreateBotAliasOutput) SetCreationDateTime(v time.Time) *CreateBotAliasOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateBotAliasOutput) SetDescription(v string) *CreateBotAliasOutput {
	s.Description = &v
	return s
}

// SetSentimentAnalysisSettings sets the SentimentAnalysisSettings field's value.
func (s *CreateBotAliasOutput) SetSentimentAnalysisSettings(v *SentimentAnalysisSettings) *CreateBotAliasOutput {
	s.SentimentAnalysisSettings = v
	return s
}

// SetTags sets the Tags field's value.
func (s *CreateBotAliasOutput) SetTags(v map[string]*string) *CreateBotAliasOutput {
	s.Tags = v
	return s
}

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

	// The name of the bot. The bot name must be unique in the account that creates
	// the bot.
	//
	// BotName is a required field
	BotName *string `locationName:"botName" min:"1" type:"string" required:"true"`

	// A list of tags to add to the bot. You can only add tags when you create a
	// bot. You can't use the UpdateBot operation to update tags. To update tags,
	// use the TagResource operation.
	BotTags map[string]*string `locationName:"botTags" type:"map"`

	// Provides information on additional privacy protections Amazon Lex should
	// use with the bot's data.
	//
	// DataPrivacy is a required field
	DataPrivacy *DataPrivacy `locationName:"dataPrivacy" type:"structure" required:"true"`

	// A description of the bot. It appears in lists to help you identify a particular
	// bot.
	Description *string `locationName:"description" type:"string"`

	// The time, in seconds, that Amazon Lex should keep information about a user's
	// conversation with the bot.
	//
	// A user interaction remains active for the amount of time specified. If no
	// conversation occurs during this time, the session expires and Amazon Lex
	// deletes any data provided before the timeout.
	//
	// You can specify between 60 (1 minute) and 86,400 (24 hours) seconds.
	//
	// IdleSessionTTLInSeconds is a required field
	IdleSessionTTLInSeconds *int64 `locationName:"idleSessionTTLInSeconds" min:"60" type:"integer" required:"true"`

	// The Amazon Resource Name (ARN) of an IAM role that has permission to access
	// the bot.
	//
	// RoleArn is a required field
	RoleArn *string `locationName:"roleArn" min:"32" type:"string" required:"true"`

	// A list of tags to add to the test alias for a bot. You can only add tags
	// when you create a bot. You can't use the UpdateAlias operation to update
	// tags. To update tags on the test alias, use the TagResource operation.
	TestBotAliasTags map[string]*string `locationName:"testBotAliasTags" type:"map"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateBotInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "CreateBotInput"}
	if s.BotName == nil {
		invalidParams.Add(request.NewErrParamRequired("BotName"))
	}
	if s.BotName != nil && len(*s.BotName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("BotName", 1))
	}
	if s.DataPrivacy == nil {
		invalidParams.Add(request.NewErrParamRequired("DataPrivacy"))
	}
	if s.IdleSessionTTLInSeconds == nil {
		invalidParams.Add(request.NewErrParamRequired("IdleSessionTTLInSeconds"))
	}
	if s.IdleSessionTTLInSeconds != nil && *s.IdleSessionTTLInSeconds < 60 {
		invalidParams.Add(request.NewErrParamMinValue("IdleSessionTTLInSeconds", 60))
	}
	if s.RoleArn == nil {
		invalidParams.Add(request.NewErrParamRequired("RoleArn"))
	}
	if s.RoleArn != nil && len(*s.RoleArn) < 32 {
		invalidParams.Add(request.NewErrParamMinLen("RoleArn", 32))
	}
	if s.DataPrivacy != nil {
		if err := s.DataPrivacy.Validate(); err != nil {
			invalidParams.AddNested("DataPrivacy", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotName sets the BotName field's value.
func (s *CreateBotInput) SetBotName(v string) *CreateBotInput {
	s.BotName = &v
	return s
}

// SetBotTags sets the BotTags field's value.
func (s *CreateBotInput) SetBotTags(v map[string]*string) *CreateBotInput {
	s.BotTags = v
	return s
}

// SetDataPrivacy sets the DataPrivacy field's value.
func (s *CreateBotInput) SetDataPrivacy(v *DataPrivacy) *CreateBotInput {
	s.DataPrivacy = v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateBotInput) SetDescription(v string) *CreateBotInput {
	s.Description = &v
	return s
}

// SetIdleSessionTTLInSeconds sets the IdleSessionTTLInSeconds field's value.
func (s *CreateBotInput) SetIdleSessionTTLInSeconds(v int64) *CreateBotInput {
	s.IdleSessionTTLInSeconds = &v
	return s
}

// SetRoleArn sets the RoleArn field's value.
func (s *CreateBotInput) SetRoleArn(v string) *CreateBotInput {
	s.RoleArn = &v
	return s
}

// SetTestBotAliasTags sets the TestBotAliasTags field's value.
func (s *CreateBotInput) SetTestBotAliasTags(v map[string]*string) *CreateBotInput {
	s.TestBotAliasTags = v
	return s
}

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

	// The identifier of the bot to create the locale for.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot to create the locale for. This can only be the draft
	// version of the bot.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// A description of the bot locale. Use this to help identify the bot locale
	// in lists.
	Description *string `locationName:"description" type:"string"`

	// The identifier of the language and locale that the bot will be used in. The
	// string must match one of the supported locales. All of the intents, slot
	// types, and slots used in the bot must have the same locale. For more information,
	// see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `locationName:"localeId" type:"string" required:"true"`

	// Determines the threshold where Amazon Lex will insert the AMAZON.FallbackIntent,
	// AMAZON.KendraSearchIntent, or both when returning alternative intents. AMAZON.FallbackIntent
	// and AMAZON.KendraSearchIntent are only inserted if they are configured for
	// the bot.
	//
	// For example, suppose a bot is configured with the confidence threshold of
	// 0.80 and the AMAZON.FallbackIntent. Amazon Lex returns three alternative
	// intents with the following confidence scores: IntentA (0.70), IntentB (0.60),
	// IntentC (0.50). The response from the PostText operation would be:
	//
	//    * AMAZON.FallbackIntent
	//
	//    * IntentA
	//
	//    * IntentB
	//
	//    * IntentC
	//
	// NluIntentConfidenceThreshold is a required field
	NluIntentConfidenceThreshold *float64 `locationName:"nluIntentConfidenceThreshold" type:"double" required:"true"`

	// The Amazon Polly voice ID that Amazon Lex uses for voice interaction with
	// the user.
	VoiceSettings *VoiceSettings `locationName:"voiceSettings" type:"structure"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateBotLocaleInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "CreateBotLocaleInput"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion == nil {
		invalidParams.Add(request.NewErrParamRequired("BotVersion"))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.LocaleId == nil {
		invalidParams.Add(request.NewErrParamRequired("LocaleId"))
	}
	if s.NluIntentConfidenceThreshold == nil {
		invalidParams.Add(request.NewErrParamRequired("NluIntentConfidenceThreshold"))
	}
	if s.VoiceSettings != nil {
		if err := s.VoiceSettings.Validate(); err != nil {
			invalidParams.AddNested("VoiceSettings", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *CreateBotLocaleInput) SetBotId(v string) *CreateBotLocaleInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateBotLocaleInput) SetBotVersion(v string) *CreateBotLocaleInput {
	s.BotVersion = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateBotLocaleInput) SetDescription(v string) *CreateBotLocaleInput {
	s.Description = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *CreateBotLocaleInput) SetLocaleId(v string) *CreateBotLocaleInput {
	s.LocaleId = &v
	return s
}

// SetNluIntentConfidenceThreshold sets the NluIntentConfidenceThreshold field's value.
func (s *CreateBotLocaleInput) SetNluIntentConfidenceThreshold(v float64) *CreateBotLocaleInput {
	s.NluIntentConfidenceThreshold = &v
	return s
}

// SetVoiceSettings sets the VoiceSettings field's value.
func (s *CreateBotLocaleInput) SetVoiceSettings(v *VoiceSettings) *CreateBotLocaleInput {
	s.VoiceSettings = v
	return s
}

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

	// The specified bot identifier.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The status of the bot.
	//
	// When the status is Creating the bot locale is being configured. When the
	// status is Building Amazon Lex is building the bot for testing and use.
	//
	// If the status of the bot is ReadyExpressTesting, you can test the bot using
	// the exact utterances specified in the bots' intents. When the bot is ready
	// for full testing or to run, the status is Built.
	//
	// If there was a problem with building the bot, the status is Failed. If the
	// bot was saved but not built, the status is NotBuilt.
	BotLocaleStatus *string `locationName:"botLocaleStatus" type:"string" enum:"BotLocaleStatus"`

	// The specified bot version.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// A timestamp specifying the date and time that the bot locale was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The specified description of the bot locale.
	Description *string `locationName:"description" type:"string"`

	// The specified locale identifier.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The specified locale name.
	LocaleName *string `locationName:"localeName" type:"string"`

	// The specified confidence threshold for inserting the AMAZON.FallbackIntent
	// and AMAZON.KendraSearchIntent intents.
	NluIntentConfidenceThreshold *float64 `locationName:"nluIntentConfidenceThreshold" type:"double"`

	// The Amazon Polly voice ID that Amazon Lex uses for voice interaction with
	// the user.
	VoiceSettings *VoiceSettings `locationName:"voiceSettings" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *CreateBotLocaleOutput) SetBotId(v string) *CreateBotLocaleOutput {
	s.BotId = &v
	return s
}

// SetBotLocaleStatus sets the BotLocaleStatus field's value.
func (s *CreateBotLocaleOutput) SetBotLocaleStatus(v string) *CreateBotLocaleOutput {
	s.BotLocaleStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateBotLocaleOutput) SetBotVersion(v string) *CreateBotLocaleOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *CreateBotLocaleOutput) SetCreationDateTime(v time.Time) *CreateBotLocaleOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateBotLocaleOutput) SetDescription(v string) *CreateBotLocaleOutput {
	s.Description = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *CreateBotLocaleOutput) SetLocaleId(v string) *CreateBotLocaleOutput {
	s.LocaleId = &v
	return s
}

// SetLocaleName sets the LocaleName field's value.
func (s *CreateBotLocaleOutput) SetLocaleName(v string) *CreateBotLocaleOutput {
	s.LocaleName = &v
	return s
}

// SetNluIntentConfidenceThreshold sets the NluIntentConfidenceThreshold field's value.
func (s *CreateBotLocaleOutput) SetNluIntentConfidenceThreshold(v float64) *CreateBotLocaleOutput {
	s.NluIntentConfidenceThreshold = &v
	return s
}

// SetVoiceSettings sets the VoiceSettings field's value.
func (s *CreateBotLocaleOutput) SetVoiceSettings(v *VoiceSettings) *CreateBotLocaleOutput {
	s.VoiceSettings = v
	return s
}

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

	// A unique identifier for a particular bot. You use this to identify the bot
	// when you call other Amazon Lex API operations.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The name specified for the bot.
	BotName *string `locationName:"botName" min:"1" type:"string"`

	// Shows the current status of the bot. The bot is first in the Creating status.
	// Once the bot is read for use, it changes to the Available status. After the
	// bot is created, you can use the Draft version of the bot.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`

	// A list of tags associated with the bot.
	BotTags map[string]*string `locationName:"botTags" type:"map"`

	// A timestamp indicating the date and time that the bot was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The data privacy settings specified for the bot.
	DataPrivacy *DataPrivacy `locationName:"dataPrivacy" type:"structure"`

	// The description specified for the bot.
	Description *string `locationName:"description" type:"string"`

	// The session idle time specified for the bot.
	IdleSessionTTLInSeconds *int64 `locationName:"idleSessionTTLInSeconds" min:"60" type:"integer"`

	// The IAM role specified for the bot.
	RoleArn *string `locationName:"roleArn" min:"32" type:"string"`

	// A list of tags associated with the test alias for the bot.
	TestBotAliasTags map[string]*string `locationName:"testBotAliasTags" type:"map"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *CreateBotOutput) SetBotId(v string) *CreateBotOutput {
	s.BotId = &v
	return s
}

// SetBotName sets the BotName field's value.
func (s *CreateBotOutput) SetBotName(v string) *CreateBotOutput {
	s.BotName = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *CreateBotOutput) SetBotStatus(v string) *CreateBotOutput {
	s.BotStatus = &v
	return s
}

// SetBotTags sets the BotTags field's value.
func (s *CreateBotOutput) SetBotTags(v map[string]*string) *CreateBotOutput {
	s.BotTags = v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *CreateBotOutput) SetCreationDateTime(v time.Time) *CreateBotOutput {
	s.CreationDateTime = &v
	return s
}

// SetDataPrivacy sets the DataPrivacy field's value.
func (s *CreateBotOutput) SetDataPrivacy(v *DataPrivacy) *CreateBotOutput {
	s.DataPrivacy = v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateBotOutput) SetDescription(v string) *CreateBotOutput {
	s.Description = &v
	return s
}

// SetIdleSessionTTLInSeconds sets the IdleSessionTTLInSeconds field's value.
func (s *CreateBotOutput) SetIdleSessionTTLInSeconds(v int64) *CreateBotOutput {
	s.IdleSessionTTLInSeconds = &v
	return s
}

// SetRoleArn sets the RoleArn field's value.
func (s *CreateBotOutput) SetRoleArn(v string) *CreateBotOutput {
	s.RoleArn = &v
	return s
}

// SetTestBotAliasTags sets the TestBotAliasTags field's value.
func (s *CreateBotOutput) SetTestBotAliasTags(v map[string]*string) *CreateBotOutput {
	s.TestBotAliasTags = v
	return s
}

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

	// The identifier of the bot to create the version for.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// Specifies the locales that Amazon Lex adds to this version. You can choose
	// the Draft version or any other previously published version for each locale.
	// When you specify a source version, the locale data is copied from the source
	// version to the new version.
	//
	// BotVersionLocaleSpecification is a required field
	BotVersionLocaleSpecification map[string]*BotVersionLocaleDetails `locationName:"botVersionLocaleSpecification" min:"1" type:"map" required:"true"`

	// A description of the version. Use the description to help identify the version
	// in lists.
	Description *string `locationName:"description" type:"string"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *CreateBotVersionInput) SetBotId(v string) *CreateBotVersionInput {
	s.BotId = &v
	return s
}

// SetBotVersionLocaleSpecification sets the BotVersionLocaleSpecification field's value.
func (s *CreateBotVersionInput) SetBotVersionLocaleSpecification(v map[string]*BotVersionLocaleDetails) *CreateBotVersionInput {
	s.BotVersionLocaleSpecification = v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateBotVersionInput) SetDescription(v string) *CreateBotVersionInput {
	s.Description = &v
	return s
}

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

	// The bot identifier specified in the request.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// When you send a request to create or update a bot, Amazon Lex sets the status
	// response element to Creating. After Amazon Lex builds the bot, it sets status
	// to Available. If Amazon Lex can't build the bot, it sets status to Failed.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`

	// The version number assigned to the version.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// The source versions used for each locale in the new version.
	BotVersionLocaleSpecification map[string]*BotVersionLocaleDetails `locationName:"botVersionLocaleSpecification" min:"1" type:"map"`

	// A timestamp of the date and time that the version was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description of the version specified in the request.
	Description *string `locationName:"description" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *CreateBotVersionOutput) SetBotId(v string) *CreateBotVersionOutput {
	s.BotId = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *CreateBotVersionOutput) SetBotStatus(v string) *CreateBotVersionOutput {
	s.BotStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateBotVersionOutput) SetBotVersion(v string) *CreateBotVersionOutput {
	s.BotVersion = &v
	return s
}

// SetBotVersionLocaleSpecification sets the BotVersionLocaleSpecification field's value.
func (s *CreateBotVersionOutput) SetBotVersionLocaleSpecification(v map[string]*BotVersionLocaleDetails) *CreateBotVersionOutput {
	s.BotVersionLocaleSpecification = v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *CreateBotVersionOutput) SetCreationDateTime(v time.Time) *CreateBotVersionOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateBotVersionOutput) SetDescription(v string) *CreateBotVersionOutput {
	s.Description = &v
	return s
}

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

	// The file format of the bot or bot locale definition files.
	//
	// FileFormat is a required field
	FileFormat *string `locationName:"fileFormat" type:"string" required:"true" enum:"ImportExportFileFormat"`

	// An password to use to encrypt the exported archive. Using a password is optional,
	// but you should encrypt the archive to protect the data in transit between
	// Amazon Lex and your local computer.
	FilePassword *string `locationName:"filePassword" min:"1" type:"string" sensitive:"true"`

	// Specifies the type of resource to export, either a bot or a bot locale. You
	// can only specify one type of resource to export.
	//
	// ResourceSpecification is a required field
	ResourceSpecification *ExportResourceSpecification `locationName:"resourceSpecification" type:"structure" required:"true"`
}

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

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

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

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

// SetFileFormat sets the FileFormat field's value.
func (s *CreateExportInput) SetFileFormat(v string) *CreateExportInput {
	s.FileFormat = &v
	return s
}

// SetFilePassword sets the FilePassword field's value.
func (s *CreateExportInput) SetFilePassword(v string) *CreateExportInput {
	s.FilePassword = &v
	return s
}

// SetResourceSpecification sets the ResourceSpecification field's value.
func (s *CreateExportInput) SetResourceSpecification(v *ExportResourceSpecification) *CreateExportInput {
	s.ResourceSpecification = v
	return s
}

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

	// The date and time that the request to export a bot was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// An identifier for a specific request to create an export.
	ExportId *string `locationName:"exportId" min:"10" type:"string"`

	// The status of the export. When the status is Completed, you can use the operation
	// to get the pre-signed S3 URL link to your exported bot or bot locale.
	ExportStatus *string `locationName:"exportStatus" type:"string" enum:"ExportStatus"`

	// The file format used for the bot or bot locale definition files.
	FileFormat *string `locationName:"fileFormat" type:"string" enum:"ImportExportFileFormat"`

	// A description of the type of resource that was exported, either a bot or
	// a bot locale.
	ResourceSpecification *ExportResourceSpecification `locationName:"resourceSpecification" type:"structure"`
}

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

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

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *CreateExportOutput) SetCreationDateTime(v time.Time) *CreateExportOutput {
	s.CreationDateTime = &v
	return s
}

// SetExportId sets the ExportId field's value.
func (s *CreateExportOutput) SetExportId(v string) *CreateExportOutput {
	s.ExportId = &v
	return s
}

// SetExportStatus sets the ExportStatus field's value.
func (s *CreateExportOutput) SetExportStatus(v string) *CreateExportOutput {
	s.ExportStatus = &v
	return s
}

// SetFileFormat sets the FileFormat field's value.
func (s *CreateExportOutput) SetFileFormat(v string) *CreateExportOutput {
	s.FileFormat = &v
	return s
}

// SetResourceSpecification sets the ResourceSpecification field's value.
func (s *CreateExportOutput) SetResourceSpecification(v *ExportResourceSpecification) *CreateExportOutput {
	s.ResourceSpecification = v
	return s
}

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

	// The identifier of the bot associated with this intent.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The identifier of the version of the bot associated with this intent.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// A description of the intent. Use the description to help identify the intent
	// in lists.
	Description *string `locationName:"description" type:"string"`

	// Specifies that Amazon Lex invokes the alias Lambda function for each user
	// input. You can invoke this Lambda function to personalize user interaction.
	//
	// For example, suppose that your bot determines that the user's name is John.
	// You Lambda function might retrieve John's information from a backend database
	// and prepopulate some of the values. For example, if you find that John is
	// gluten intolerant, you might set the corresponding intent slot, glutenIntolerant
	// to true. You might find John's phone number and set the corresponding session
	// attribute.
	DialogCodeHook *DialogCodeHookSettings `locationName:"dialogCodeHook" type:"structure"`

	// Specifies that Amazon Lex invokes the alias Lambda function when the intent
	// is ready for fulfillment. You can invoke this function to complete the bot's
	// transaction with the user.
	//
	// For example, in a pizza ordering bot, the Lambda function can look up the
	// closest pizza restaurant to the customer's location and then place an order
	// on the customer's behalf.
	FulfillmentCodeHook *FulfillmentCodeHookSettings `locationName:"fulfillmentCodeHook" type:"structure"`

	// A list of contexts that must be active for this intent to be considered by
	// Amazon Lex.
	//
	// When an intent has an input context list, Amazon Lex only considers using
	// the intent in an interaction with the user when the specified contexts are
	// included in the active context list for the session. If the contexts are
	// not active, then Amazon Lex will not use the intent.
	//
	// A context can be automatically activated using the outputContexts property
	// or it can be set at runtime.
	//
	// For example, if there are two intents with different input contexts that
	// respond to the same utterances, only the intent with the active context will
	// respond.
	//
	// An intent may have up to 5 input contexts. If an intent has multiple input
	// contexts, all of the contexts must be active to consider the intent.
	InputContexts []*InputContext `locationName:"inputContexts" type:"list"`

	// Sets the response that Amazon Lex sends to the user when the intent is closed.
	IntentClosingSetting *IntentClosingSetting `locationName:"intentClosingSetting" type:"structure"`

	// Provides prompts that Amazon Lex sends to the user to confirm the completion
	// of an intent. If the user answers "no," the settings contain a statement
	// that is sent to the user to end the intent.
	IntentConfirmationSetting *IntentConfirmationSetting `locationName:"intentConfirmationSetting" type:"structure"`

	// The name of the intent. Intent names must be unique in the locale that contains
	// the intent and cannot match the name of any built-in intent.
	//
	// IntentName is a required field
	IntentName *string `locationName:"intentName" min:"1" type:"string" required:"true"`

	// Configuration information required to use the AMAZON.KendraSearchIntent intent
	// to connect to an Amazon Kendra index. The AMAZON.KendraSearchIntent intent
	// is called when Amazon Lex can't determine another intent to invoke.
	KendraConfiguration *KendraConfiguration `locationName:"kendraConfiguration" type:"structure"`

	// The identifier of the language and locale where this intent is used. All
	// of the bots, slot types, and slots used by the intent must have the same
	// locale. For more information, see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// A lists of contexts that the intent activates when it is fulfilled.
	//
	// You can use an output context to indicate the intents that Amazon Lex should
	// consider for the next turn of the conversation with a customer.
	//
	// When you use the outputContextsList property, all of the contexts specified
	// in the list are activated when the intent is fulfilled. You can set up to
	// 10 output contexts. You can also set the number of conversation turns that
	// the context should be active, or the length of time that the context should
	// be active.
	OutputContexts []*OutputContext `locationName:"outputContexts" type:"list"`

	// A unique identifier for the built-in intent to base this intent on.
	ParentIntentSignature *string `locationName:"parentIntentSignature" type:"string"`

	// An array of strings that a user might say to signal the intent. For example,
	// "I want a pizza", or "I want a {PizzaSize} pizza".
	//
	// In an utterance, slot names are enclosed in curly braces ("{", "}") to indicate
	// where they should be displayed in the utterance shown to the user..
	SampleUtterances []*SampleUtterance `locationName:"sampleUtterances" type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateIntentInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "CreateIntentInput"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion == nil {
		invalidParams.Add(request.NewErrParamRequired("BotVersion"))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.IntentName == nil {
		invalidParams.Add(request.NewErrParamRequired("IntentName"))
	}
	if s.IntentName != nil && len(*s.IntentName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("IntentName", 1))
	}
	if s.LocaleId == nil {
		invalidParams.Add(request.NewErrParamRequired("LocaleId"))
	}
	if s.LocaleId != nil && len(*s.LocaleId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("LocaleId", 1))
	}
	if s.DialogCodeHook != nil {
		if err := s.DialogCodeHook.Validate(); err != nil {
			invalidParams.AddNested("DialogCodeHook", err.(request.ErrInvalidParams))
		}
	}
	if s.FulfillmentCodeHook != nil {
		if err := s.FulfillmentCodeHook.Validate(); err != nil {
			invalidParams.AddNested("FulfillmentCodeHook", err.(request.ErrInvalidParams))
		}
	}
	if s.InputContexts != nil {
		for i, v := range s.InputContexts {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "InputContexts", i), err.(request.ErrInvalidParams))
			}
		}
	}
	if s.IntentClosingSetting != nil {
		if err := s.IntentClosingSetting.Validate(); err != nil {
			invalidParams.AddNested("IntentClosingSetting", err.(request.ErrInvalidParams))
		}
	}
	if s.IntentConfirmationSetting != nil {
		if err := s.IntentConfirmationSetting.Validate(); err != nil {
			invalidParams.AddNested("IntentConfirmationSetting", err.(request.ErrInvalidParams))
		}
	}
	if s.KendraConfiguration != nil {
		if err := s.KendraConfiguration.Validate(); err != nil {
			invalidParams.AddNested("KendraConfiguration", err.(request.ErrInvalidParams))
		}
	}
	if s.OutputContexts != nil {
		for i, v := range s.OutputContexts {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "OutputContexts", i), err.(request.ErrInvalidParams))
			}
		}
	}
	if s.SampleUtterances != nil {
		for i, v := range s.SampleUtterances {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SampleUtterances", i), err.(request.ErrInvalidParams))
			}
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *CreateIntentInput) SetBotId(v string) *CreateIntentInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateIntentInput) SetBotVersion(v string) *CreateIntentInput {
	s.BotVersion = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateIntentInput) SetDescription(v string) *CreateIntentInput {
	s.Description = &v
	return s
}

// SetDialogCodeHook sets the DialogCodeHook field's value.
func (s *CreateIntentInput) SetDialogCodeHook(v *DialogCodeHookSettings) *CreateIntentInput {
	s.DialogCodeHook = v
	return s
}

// SetFulfillmentCodeHook sets the FulfillmentCodeHook field's value.
func (s *CreateIntentInput) SetFulfillmentCodeHook(v *FulfillmentCodeHookSettings) *CreateIntentInput {
	s.FulfillmentCodeHook = v
	return s
}

// SetInputContexts sets the InputContexts field's value.
func (s *CreateIntentInput) SetInputContexts(v []*InputContext) *CreateIntentInput {
	s.InputContexts = v
	return s
}

// SetIntentClosingSetting sets the IntentClosingSetting field's value.
func (s *CreateIntentInput) SetIntentClosingSetting(v *IntentClosingSetting) *CreateIntentInput {
	s.IntentClosingSetting = v
	return s
}

// SetIntentConfirmationSetting sets the IntentConfirmationSetting field's value.
func (s *CreateIntentInput) SetIntentConfirmationSetting(v *IntentConfirmationSetting) *CreateIntentInput {
	s.IntentConfirmationSetting = v
	return s
}

// SetIntentName sets the IntentName field's value.
func (s *CreateIntentInput) SetIntentName(v string) *CreateIntentInput {
	s.IntentName = &v
	return s
}

// SetKendraConfiguration sets the KendraConfiguration field's value.
func (s *CreateIntentInput) SetKendraConfiguration(v *KendraConfiguration) *CreateIntentInput {
	s.KendraConfiguration = v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *CreateIntentInput) SetLocaleId(v string) *CreateIntentInput {
	s.LocaleId = &v
	return s
}

// SetOutputContexts sets the OutputContexts field's value.
func (s *CreateIntentInput) SetOutputContexts(v []*OutputContext) *CreateIntentInput {
	s.OutputContexts = v
	return s
}

// SetParentIntentSignature sets the ParentIntentSignature field's value.
func (s *CreateIntentInput) SetParentIntentSignature(v string) *CreateIntentInput {
	s.ParentIntentSignature = &v
	return s
}

// SetSampleUtterances sets the SampleUtterances field's value.
func (s *CreateIntentInput) SetSampleUtterances(v []*SampleUtterance) *CreateIntentInput {
	s.SampleUtterances = v
	return s
}

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

	// The identifier of the bot associated with the intent.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The identifier of the version of the bot associated with the intent.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// A timestamp of the date and time that the intent was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description specified for the intent.
	Description *string `locationName:"description" type:"string"`

	// The dialog Lambda function specified for the intent.
	DialogCodeHook *DialogCodeHookSettings `locationName:"dialogCodeHook" type:"structure"`

	// The fulfillment Lambda function specified for the intent.
	FulfillmentCodeHook *FulfillmentCodeHookSettings `locationName:"fulfillmentCodeHook" type:"structure"`

	// The list of input contexts specified for the intent.
	InputContexts []*InputContext `locationName:"inputContexts" type:"list"`

	// The closing setting specified for the intent.
	IntentClosingSetting *IntentClosingSetting `locationName:"intentClosingSetting" type:"structure"`

	// The confirmation setting specified for the intent.
	IntentConfirmationSetting *IntentConfirmationSetting `locationName:"intentConfirmationSetting" type:"structure"`

	// A unique identifier for the intent.
	IntentId *string `locationName:"intentId" min:"10" type:"string"`

	// The name specified for the intent.
	IntentName *string `locationName:"intentName" min:"1" type:"string"`

	// Configuration for searching a Amazon Kendra index specified for the intent.
	KendraConfiguration *KendraConfiguration `locationName:"kendraConfiguration" type:"structure"`

	// The locale that the intent is specified to use.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The list of output contexts specified for the intent.
	OutputContexts []*OutputContext `locationName:"outputContexts" type:"list"`

	// The signature of the parent intent specified for the intent.
	ParentIntentSignature *string `locationName:"parentIntentSignature" type:"string"`

	// The sample utterances specified for the intent.
	SampleUtterances []*SampleUtterance `locationName:"sampleUtterances" type:"list"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *CreateIntentOutput) SetBotId(v string) *CreateIntentOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateIntentOutput) SetBotVersion(v string) *CreateIntentOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *CreateIntentOutput) SetCreationDateTime(v time.Time) *CreateIntentOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateIntentOutput) SetDescription(v string) *CreateIntentOutput {
	s.Description = &v
	return s
}

// SetDialogCodeHook sets the DialogCodeHook field's value.
func (s *CreateIntentOutput) SetDialogCodeHook(v *DialogCodeHookSettings) *CreateIntentOutput {
	s.DialogCodeHook = v
	return s
}

// SetFulfillmentCodeHook sets the FulfillmentCodeHook field's value.
func (s *CreateIntentOutput) SetFulfillmentCodeHook(v *FulfillmentCodeHookSettings) *CreateIntentOutput {
	s.FulfillmentCodeHook = v
	return s
}

// SetInputContexts sets the InputContexts field's value.
func (s *CreateIntentOutput) SetInputContexts(v []*InputContext) *CreateIntentOutput {
	s.InputContexts = v
	return s
}

// SetIntentClosingSetting sets the IntentClosingSetting field's value.
func (s *CreateIntentOutput) SetIntentClosingSetting(v *IntentClosingSetting) *CreateIntentOutput {
	s.IntentClosingSetting = v
	return s
}

// SetIntentConfirmationSetting sets the IntentConfirmationSetting field's value.
func (s *CreateIntentOutput) SetIntentConfirmationSetting(v *IntentConfirmationSetting) *CreateIntentOutput {
	s.IntentConfirmationSetting = v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *CreateIntentOutput) SetIntentId(v string) *CreateIntentOutput {
	s.IntentId = &v
	return s
}

// SetIntentName sets the IntentName field's value.
func (s *CreateIntentOutput) SetIntentName(v string) *CreateIntentOutput {
	s.IntentName = &v
	return s
}

// SetKendraConfiguration sets the KendraConfiguration field's value.
func (s *CreateIntentOutput) SetKendraConfiguration(v *KendraConfiguration) *CreateIntentOutput {
	s.KendraConfiguration = v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *CreateIntentOutput) SetLocaleId(v string) *CreateIntentOutput {
	s.LocaleId = &v
	return s
}

// SetOutputContexts sets the OutputContexts field's value.
func (s *CreateIntentOutput) SetOutputContexts(v []*OutputContext) *CreateIntentOutput {
	s.OutputContexts = v
	return s
}

// SetParentIntentSignature sets the ParentIntentSignature field's value.
func (s *CreateIntentOutput) SetParentIntentSignature(v string) *CreateIntentOutput {
	s.ParentIntentSignature = &v
	return s
}

// SetSampleUtterances sets the SampleUtterances field's value.
func (s *CreateIntentOutput) SetSampleUtterances(v []*SampleUtterance) *CreateIntentOutput {
	s.SampleUtterances = v
	return s
}

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

	// A resource policy to add to the resource. The policy is a JSON structure
	// that contains one or more statements that define the policy. The policy must
	// follow the IAM syntax. For more information about the contents of a JSON
	// policy document, see IAM JSON policy reference (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html).
	//
	// If the policy isn't valid, Amazon Lex returns a validation exception.
	//
	// Policy is a required field
	Policy *string `locationName:"policy" min:"2" type:"string" required:"true"`

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy is attached to.
	//
	// ResourceArn is a required field
	ResourceArn *string `location:"uri" locationName:"resourceArn" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetPolicy sets the Policy field's value.
func (s *CreateResourcePolicyInput) SetPolicy(v string) *CreateResourcePolicyInput {
	s.Policy = &v
	return s
}

// SetResourceArn sets the ResourceArn field's value.
func (s *CreateResourcePolicyInput) SetResourceArn(v string) *CreateResourcePolicyInput {
	s.ResourceArn = &v
	return s
}

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

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy was attached to.
	ResourceArn *string `locationName:"resourceArn" min:"1" type:"string"`

	// The current revision of the resource policy. Use the revision ID to make
	// sure that you are updating the most current version of a resource policy
	// when you add a policy statement to a resource, delete a resource, or update
	// a resource.
	RevisionId *string `locationName:"revisionId" min:"1" type:"string"`
}

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

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

// SetResourceArn sets the ResourceArn field's value.
func (s *CreateResourcePolicyOutput) SetResourceArn(v string) *CreateResourcePolicyOutput {
	s.ResourceArn = &v
	return s
}

// SetRevisionId sets the RevisionId field's value.
func (s *CreateResourcePolicyOutput) SetRevisionId(v string) *CreateResourcePolicyOutput {
	s.RevisionId = &v
	return s
}

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

	// The Amazon Lex action that this policy either allows or denies. The action
	// must apply to the resource type of the specified ARN. For more information,
	// see Actions, resources, and condition keys for Amazon Lex V2 (https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlexv2.html).
	//
	// Action is a required field
	Action []*string `locationName:"action" type:"list" required:"true"`

	// Specifies a condition when the policy is in effect. If the principal of the
	// policy is a service principal, you must provide two condition blocks, one
	// with a SourceAccount global condition key and one with a SourceArn global
	// condition key.
	//
	// For more information, see IAM JSON policy elements: Condition (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).
	Condition map[string]map[string]*string `locationName:"condition" type:"map"`

	// Determines whether the statement allows or denies access to the resource.
	//
	// Effect is a required field
	Effect *string `locationName:"effect" type:"string" required:"true" enum:"Effect"`

	// The identifier of the revision of the policy to edit. If this revision ID
	// doesn't match the current revision ID, Amazon Lex throws an exception.
	//
	// If you don't specify a revision, Amazon Lex overwrites the contents of the
	// policy with the new values.
	ExpectedRevisionId *string `location:"querystring" locationName:"expectedRevisionId" min:"1" type:"string"`

	// An IAM principal, such as an IAM users, IAM roles, or AWS services that is
	// allowed or denied access to a resource. For more information, see AWS JSON
	// policy elements: Principal (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html).
	//
	// Principal is a required field
	Principal []*Principal `locationName:"principal" type:"list" required:"true"`

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy is attached to.
	//
	// ResourceArn is a required field
	ResourceArn *string `location:"uri" locationName:"resourceArn" min:"1" type:"string" required:"true"`

	// The name of the statement. The ID is the same as the Sid IAM property. The
	// statement name must be unique within the policy. For more information, see
	// IAM JSON policy elements: Sid (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_sid.html).
	//
	// StatementId is a required field
	StatementId *string `locationName:"statementId" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetAction sets the Action field's value.
func (s *CreateResourcePolicyStatementInput) SetAction(v []*string) *CreateResourcePolicyStatementInput {
	s.Action = v
	return s
}

// SetCondition sets the Condition field's value.
func (s *CreateResourcePolicyStatementInput) SetCondition(v map[string]map[string]*string) *CreateResourcePolicyStatementInput {
	s.Condition = v
	return s
}

// SetEffect sets the Effect field's value.
func (s *CreateResourcePolicyStatementInput) SetEffect(v string) *CreateResourcePolicyStatementInput {
	s.Effect = &v
	return s
}

// SetExpectedRevisionId sets the ExpectedRevisionId field's value.
func (s *CreateResourcePolicyStatementInput) SetExpectedRevisionId(v string) *CreateResourcePolicyStatementInput {
	s.ExpectedRevisionId = &v
	return s
}

// SetPrincipal sets the Principal field's value.
func (s *CreateResourcePolicyStatementInput) SetPrincipal(v []*Principal) *CreateResourcePolicyStatementInput {
	s.Principal = v
	return s
}

// SetResourceArn sets the ResourceArn field's value.
func (s *CreateResourcePolicyStatementInput) SetResourceArn(v string) *CreateResourcePolicyStatementInput {
	s.ResourceArn = &v
	return s
}

// SetStatementId sets the StatementId field's value.
func (s *CreateResourcePolicyStatementInput) SetStatementId(v string) *CreateResourcePolicyStatementInput {
	s.StatementId = &v
	return s
}

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

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy is attached to.
	ResourceArn *string `locationName:"resourceArn" min:"1" type:"string"`

	// The current revision of the resource policy. Use the revision ID to make
	// sure that you are updating the most current version of a resource policy
	// when you add a policy statement to a resource, delete a resource, or update
	// a resource.
	RevisionId *string `locationName:"revisionId" min:"1" type:"string"`
}

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

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

// SetResourceArn sets the ResourceArn field's value.
func (s *CreateResourcePolicyStatementOutput) SetResourceArn(v string) *CreateResourcePolicyStatementOutput {
	s.ResourceArn = &v
	return s
}

// SetRevisionId sets the RevisionId field's value.
func (s *CreateResourcePolicyStatementOutput) SetRevisionId(v string) *CreateResourcePolicyStatementOutput {
	s.RevisionId = &v
	return s
}

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

	// The identifier of the bot associated with the slot.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot associated with the slot.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// A description of the slot. Use this to help identify the slot in lists.
	Description *string `locationName:"description" type:"string"`

	// The identifier of the intent that contains the slot.
	//
	// IntentId is a required field
	IntentId *string `location:"uri" locationName:"intentId" min:"10" type:"string" required:"true"`

	// The identifier of the language and locale that the slot will be used in.
	// The string must match one of the supported locales. All of the bots, intents,
	// slot types used by the slot must have the same locale. For more information,
	// see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// Indicates whether the slot returns multiple values in one response. Multi-value
	// slots are only available in the en-US locale. If you set this value to true
	// in any other locale, Amazon Lex throws a ValidationException.
	//
	// If the multipleValuesSetting is not set, the default value is false.
	MultipleValuesSetting *MultipleValuesSetting `locationName:"multipleValuesSetting" type:"structure"`

	// Determines how slot values are used in Amazon CloudWatch logs. If the value
	// of the obfuscationSetting parameter is DefaultObfuscation, slot values are
	// obfuscated in the log output. If the value is None, the actual value is present
	// in the log output.
	//
	// The default is to obfuscate values in the CloudWatch logs.
	ObfuscationSetting *ObfuscationSetting `locationName:"obfuscationSetting" type:"structure"`

	// The name of the slot. Slot names must be unique within the bot that contains
	// the slot.
	//
	// SlotName is a required field
	SlotName *string `locationName:"slotName" min:"1" type:"string" required:"true"`

	// The unique identifier for the slot type associated with this slot. The slot
	// type determines the values that can be entered into the slot.
	//
	// SlotTypeId is a required field
	SlotTypeId *string `locationName:"slotTypeId" min:"1" type:"string" required:"true"`

	// Specifies prompts that Amazon Lex sends to the user to elicit a response
	// that provides the value for the slot.
	//
	// ValueElicitationSetting is a required field
	ValueElicitationSetting *SlotValueElicitationSetting `locationName:"valueElicitationSetting" type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateSlotInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "CreateSlotInput"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion == nil {
		invalidParams.Add(request.NewErrParamRequired("BotVersion"))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.IntentId == nil {
		invalidParams.Add(request.NewErrParamRequired("IntentId"))
	}
	if s.IntentId != nil && len(*s.IntentId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("IntentId", 10))
	}
	if s.LocaleId == nil {
		invalidParams.Add(request.NewErrParamRequired("LocaleId"))
	}
	if s.LocaleId != nil && len(*s.LocaleId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("LocaleId", 1))
	}
	if s.SlotName == nil {
		invalidParams.Add(request.NewErrParamRequired("SlotName"))
	}
	if s.SlotName != nil && len(*s.SlotName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SlotName", 1))
	}
	if s.SlotTypeId == nil {
		invalidParams.Add(request.NewErrParamRequired("SlotTypeId"))
	}
	if s.SlotTypeId != nil && len(*s.SlotTypeId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SlotTypeId", 1))
	}
	if s.ValueElicitationSetting == nil {
		invalidParams.Add(request.NewErrParamRequired("ValueElicitationSetting"))
	}
	if s.ObfuscationSetting != nil {
		if err := s.ObfuscationSetting.Validate(); err != nil {
			invalidParams.AddNested("ObfuscationSetting", err.(request.ErrInvalidParams))
		}
	}
	if s.ValueElicitationSetting != nil {
		if err := s.ValueElicitationSetting.Validate(); err != nil {
			invalidParams.AddNested("ValueElicitationSetting", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *CreateSlotInput) SetBotId(v string) *CreateSlotInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateSlotInput) SetBotVersion(v string) *CreateSlotInput {
	s.BotVersion = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateSlotInput) SetDescription(v string) *CreateSlotInput {
	s.Description = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *CreateSlotInput) SetIntentId(v string) *CreateSlotInput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *CreateSlotInput) SetLocaleId(v string) *CreateSlotInput {
	s.LocaleId = &v
	return s
}

// SetMultipleValuesSetting sets the MultipleValuesSetting field's value.
func (s *CreateSlotInput) SetMultipleValuesSetting(v *MultipleValuesSetting) *CreateSlotInput {
	s.MultipleValuesSetting = v
	return s
}

// SetObfuscationSetting sets the ObfuscationSetting field's value.
func (s *CreateSlotInput) SetObfuscationSetting(v *ObfuscationSetting) *CreateSlotInput {
	s.ObfuscationSetting = v
	return s
}

// SetSlotName sets the SlotName field's value.
func (s *CreateSlotInput) SetSlotName(v string) *CreateSlotInput {
	s.SlotName = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *CreateSlotInput) SetSlotTypeId(v string) *CreateSlotInput {
	s.SlotTypeId = &v
	return s
}

// SetValueElicitationSetting sets the ValueElicitationSetting field's value.
func (s *CreateSlotInput) SetValueElicitationSetting(v *SlotValueElicitationSetting) *CreateSlotInput {
	s.ValueElicitationSetting = v
	return s
}

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

	// The unique identifier of the bot associated with the slot.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot associated with the slot.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// The timestamp of the date and time that the slot was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description associated with the slot.
	Description *string `locationName:"description" type:"string"`

	// The unique identifier of the intent associated with the slot.
	IntentId *string `locationName:"intentId" min:"10" type:"string"`

	// The language and local specified for the slot.
	LocaleId *string `locationName:"localeId" type:"string"`

	// Indicates whether the slot returns multiple values in one response.
	MultipleValuesSetting *MultipleValuesSetting `locationName:"multipleValuesSetting" type:"structure"`

	// Indicates whether the slot is configured to obfuscate values in Amazon CloudWatch
	// logs.
	ObfuscationSetting *ObfuscationSetting `locationName:"obfuscationSetting" type:"structure"`

	// The unique identifier associated with the slot. Use this to identify the
	// slot when you update or delete it.
	SlotId *string `locationName:"slotId" min:"10" type:"string"`

	// The name specified for the slot.
	SlotName *string `locationName:"slotName" min:"1" type:"string"`

	// The unique identifier of the slot type associated with this slot.
	SlotTypeId *string `locationName:"slotTypeId" min:"1" type:"string"`

	// The value elicitation settings specified for the slot.
	ValueElicitationSetting *SlotValueElicitationSetting `locationName:"valueElicitationSetting" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *CreateSlotOutput) SetBotId(v string) *CreateSlotOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateSlotOutput) SetBotVersion(v string) *CreateSlotOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *CreateSlotOutput) SetCreationDateTime(v time.Time) *CreateSlotOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateSlotOutput) SetDescription(v string) *CreateSlotOutput {
	s.Description = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *CreateSlotOutput) SetIntentId(v string) *CreateSlotOutput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *CreateSlotOutput) SetLocaleId(v string) *CreateSlotOutput {
	s.LocaleId = &v
	return s
}

// SetMultipleValuesSetting sets the MultipleValuesSetting field's value.
func (s *CreateSlotOutput) SetMultipleValuesSetting(v *MultipleValuesSetting) *CreateSlotOutput {
	s.MultipleValuesSetting = v
	return s
}

// SetObfuscationSetting sets the ObfuscationSetting field's value.
func (s *CreateSlotOutput) SetObfuscationSetting(v *ObfuscationSetting) *CreateSlotOutput {
	s.ObfuscationSetting = v
	return s
}

// SetSlotId sets the SlotId field's value.
func (s *CreateSlotOutput) SetSlotId(v string) *CreateSlotOutput {
	s.SlotId = &v
	return s
}

// SetSlotName sets the SlotName field's value.
func (s *CreateSlotOutput) SetSlotName(v string) *CreateSlotOutput {
	s.SlotName = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *CreateSlotOutput) SetSlotTypeId(v string) *CreateSlotOutput {
	s.SlotTypeId = &v
	return s
}

// SetValueElicitationSetting sets the ValueElicitationSetting field's value.
func (s *CreateSlotOutput) SetValueElicitationSetting(v *SlotValueElicitationSetting) *CreateSlotOutput {
	s.ValueElicitationSetting = v
	return s
}

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

	// The identifier of the bot associated with this slot type.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The identifier of the bot version associated with this slot type.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// A description of the slot type. Use the description to help identify the
	// slot type in lists.
	Description *string `locationName:"description" type:"string"`

	// The identifier of the language and locale that the slot type will be used
	// in. The string must match one of the supported locales. All of the bots,
	// intents, and slots used by the slot type must have the same locale. For more
	// information, see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The built-in slot type used as a parent of this slot type. When you define
	// a parent slot type, the new slot type has the configuration of the parent
	// slot type.
	//
	// Only AMAZON.AlphaNumeric is supported.
	ParentSlotTypeSignature *string `locationName:"parentSlotTypeSignature" type:"string"`

	// The name for the slot. A slot type name must be unique within the account.
	//
	// SlotTypeName is a required field
	SlotTypeName *string `locationName:"slotTypeName" min:"1" type:"string" required:"true"`

	// A list of SlotTypeValue objects that defines the values that the slot type
	// can take. Each value can have a list of synonyms, additional values that
	// help train the machine learning model about the values that it resolves for
	// a slot.
	SlotTypeValues []*SlotTypeValue `locationName:"slotTypeValues" min:"1" type:"list"`

	// Determines the strategy that Amazon Lex uses to select a value from the list
	// of possible values. The field can be set to one of the following values:
	//
	//    * OriginalValue - Returns the value entered by the user, if the user value
	//    is similar to the slot value.
	//
	//    * TopResolution - If there is a resolution list for the slot, return the
	//    first value in the resolution list. If there is no resolution list, return
	//    null.
	//
	// If you don't specify the valueSelectionSetting parameter, the default is
	// OriginalValue.
	//
	// ValueSelectionSetting is a required field
	ValueSelectionSetting *SlotValueSelectionSetting `locationName:"valueSelectionSetting" type:"structure" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *CreateSlotTypeInput) SetBotId(v string) *CreateSlotTypeInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateSlotTypeInput) SetBotVersion(v string) *CreateSlotTypeInput {
	s.BotVersion = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateSlotTypeInput) SetDescription(v string) *CreateSlotTypeInput {
	s.Description = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *CreateSlotTypeInput) SetLocaleId(v string) *CreateSlotTypeInput {
	s.LocaleId = &v
	return s
}

// SetParentSlotTypeSignature sets the ParentSlotTypeSignature field's value.
func (s *CreateSlotTypeInput) SetParentSlotTypeSignature(v string) *CreateSlotTypeInput {
	s.ParentSlotTypeSignature = &v
	return s
}

// SetSlotTypeName sets the SlotTypeName field's value.
func (s *CreateSlotTypeInput) SetSlotTypeName(v string) *CreateSlotTypeInput {
	s.SlotTypeName = &v
	return s
}

// SetSlotTypeValues sets the SlotTypeValues field's value.
func (s *CreateSlotTypeInput) SetSlotTypeValues(v []*SlotTypeValue) *CreateSlotTypeInput {
	s.SlotTypeValues = v
	return s
}

// SetValueSelectionSetting sets the ValueSelectionSetting field's value.
func (s *CreateSlotTypeInput) SetValueSelectionSetting(v *SlotValueSelectionSetting) *CreateSlotTypeInput {
	s.ValueSelectionSetting = v
	return s
}

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

	// The identifier for the bot associated with the slot type.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot associated with the slot type.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// A timestamp of the date and time that the slot type was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description specified for the slot type.
	Description *string `locationName:"description" type:"string"`

	// The specified language and local specified for the slot type.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The signature of the base slot type specified for the slot type.
	ParentSlotTypeSignature *string `locationName:"parentSlotTypeSignature" type:"string"`

	// The unique identifier assigned to the slot type. Use this to identify the
	// slot type in the UpdateSlotType and DeleteSlotType operations.
	SlotTypeId *string `locationName:"slotTypeId" min:"10" type:"string"`

	// The name specified for the slot type.
	SlotTypeName *string `locationName:"slotTypeName" min:"1" type:"string"`

	// The list of values that the slot type can assume.
	SlotTypeValues []*SlotTypeValue `locationName:"slotTypeValues" min:"1" type:"list"`

	// The strategy that Amazon Lex uses to select a value from the list of possible
	// values.
	ValueSelectionSetting *SlotValueSelectionSetting `locationName:"valueSelectionSetting" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *CreateSlotTypeOutput) SetBotId(v string) *CreateSlotTypeOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *CreateSlotTypeOutput) SetBotVersion(v string) *CreateSlotTypeOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *CreateSlotTypeOutput) SetCreationDateTime(v time.Time) *CreateSlotTypeOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *CreateSlotTypeOutput) SetDescription(v string) *CreateSlotTypeOutput {
	s.Description = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *CreateSlotTypeOutput) SetLocaleId(v string) *CreateSlotTypeOutput {
	s.LocaleId = &v
	return s
}

// SetParentSlotTypeSignature sets the ParentSlotTypeSignature field's value.
func (s *CreateSlotTypeOutput) SetParentSlotTypeSignature(v string) *CreateSlotTypeOutput {
	s.ParentSlotTypeSignature = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *CreateSlotTypeOutput) SetSlotTypeId(v string) *CreateSlotTypeOutput {
	s.SlotTypeId = &v
	return s
}

// SetSlotTypeName sets the SlotTypeName field's value.
func (s *CreateSlotTypeOutput) SetSlotTypeName(v string) *CreateSlotTypeOutput {
	s.SlotTypeName = &v
	return s
}

// SetSlotTypeValues sets the SlotTypeValues field's value.
func (s *CreateSlotTypeOutput) SetSlotTypeValues(v []*SlotTypeValue) *CreateSlotTypeOutput {
	s.SlotTypeValues = v
	return s
}

// SetValueSelectionSetting sets the ValueSelectionSetting field's value.
func (s *CreateSlotTypeOutput) SetValueSelectionSetting(v *SlotValueSelectionSetting) *CreateSlotTypeOutput {
	s.ValueSelectionSetting = v
	return s
}

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

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

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

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

	// An identifier for a unique import job. Use it when you call the operation.
	ImportId *string `locationName:"importId" min:"10" type:"string"`

	// A pre-signed S3 write URL. Upload the zip archive file that contains the
	// definition of your bot or bot locale.
	UploadUrl *string `locationName:"uploadUrl" min:"1" type:"string"`
}

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

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

// SetImportId sets the ImportId field's value.
func (s *CreateUploadUrlOutput) SetImportId(v string) *CreateUploadUrlOutput {
	s.ImportId = &v
	return s
}

// SetUploadUrl sets the UploadUrl field's value.
func (s *CreateUploadUrlOutput) SetUploadUrl(v string) *CreateUploadUrlOutput {
	s.UploadUrl = &v
	return s
}

// A custom response string that Amazon Lex sends to your application. You define
// the content and structure the string.
type CustomPayload struct {
	_ struct{} `type:"structure"`

	// The string that is sent to your application.
	//
	// Value is a required field
	Value *string `locationName:"value" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetValue sets the Value field's value.
func (s *CustomPayload) SetValue(v string) *CustomPayload {
	s.Value = &v
	return s
}

// By default, data stored by Amazon Lex is encrypted. The DataPrivacy structure
// provides settings that determine how Amazon Lex handles special cases of
// securing the data for your bot.
type DataPrivacy struct {
	_ struct{} `type:"structure"`

	// For each Amazon Lex bot created with the Amazon Lex Model Building Service,
	// you must specify whether your use of Amazon Lex is related to a website,
	// program, or other application that is directed or targeted, in whole or in
	// part, to children under age 13 and subject to the Children's Online Privacy
	// Protection Act (COPPA) by specifying true or false in the childDirected field.
	// By specifying true in the childDirected field, you confirm that your use
	// of Amazon Lex is related to a website, program, or other application that
	// is directed or targeted, in whole or in part, to children under age 13 and
	// subject to COPPA. By specifying false in the childDirected field, you confirm
	// that your use of Amazon Lex is not related to a website, program, or other
	// application that is directed or targeted, in whole or in part, to children
	// under age 13 and subject to COPPA. You may not specify a default value for
	// the childDirected field that does not accurately reflect whether your use
	// of Amazon Lex is related to a website, program, or other application that
	// is directed or targeted, in whole or in part, to children under age 13 and
	// subject to COPPA. If your use of Amazon Lex relates to a website, program,
	// or other application that is directed in whole or in part, to children under
	// age 13, you must obtain any required verifiable parental consent under COPPA.
	// For information regarding the use of Amazon Lex in connection with websites,
	// programs, or other applications that are directed or targeted, in whole or
	// in part, to children under age 13, see the Amazon Lex FAQ (https://aws.amazon.com/lex/faqs#data-security).
	//
	// ChildDirected is a required field
	ChildDirected *bool `locationName:"childDirected" type:"boolean" required:"true"`
}

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

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

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

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

// SetChildDirected sets the ChildDirected field's value.
func (s *DataPrivacy) SetChildDirected(v bool) *DataPrivacy {
	s.ChildDirected = &v
	return s
}

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

	// The unique identifier of the bot alias to delete.
	//
	// BotAliasId is a required field
	BotAliasId *string `location:"uri" locationName:"botAliasId" min:"10" type:"string" required:"true"`

	// The unique identifier of the bot associated with the alias to delete.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// When this parameter is true, Amazon Lex doesn't check to see if any other
	// resource is using the alias before it is deleted.
	SkipResourceInUseCheck *bool `location:"querystring" locationName:"skipResourceInUseCheck" type:"boolean"`
}

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

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

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

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

// SetBotAliasId sets the BotAliasId field's value.
func (s *DeleteBotAliasInput) SetBotAliasId(v string) *DeleteBotAliasInput {
	s.BotAliasId = &v
	return s
}

// SetBotId sets the BotId field's value.
func (s *DeleteBotAliasInput) SetBotId(v string) *DeleteBotAliasInput {
	s.BotId = &v
	return s
}

// SetSkipResourceInUseCheck sets the SkipResourceInUseCheck field's value.
func (s *DeleteBotAliasInput) SetSkipResourceInUseCheck(v bool) *DeleteBotAliasInput {
	s.SkipResourceInUseCheck = &v
	return s
}

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

	// The unique identifier of the bot alias to delete.
	BotAliasId *string `locationName:"botAliasId" min:"10" type:"string"`

	// The current status of the alias. The status is Deleting while the alias is
	// in the process of being deleted. Once the alias is deleted, it will no longer
	// appear in the list of aliases returned by the ListBotAliases operation.
	BotAliasStatus *string `locationName:"botAliasStatus" type:"string" enum:"BotAliasStatus"`

	// The unique identifier of the bot that contains the alias to delete.
	BotId *string `locationName:"botId" min:"10" type:"string"`
}

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

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

// SetBotAliasId sets the BotAliasId field's value.
func (s *DeleteBotAliasOutput) SetBotAliasId(v string) *DeleteBotAliasOutput {
	s.BotAliasId = &v
	return s
}

// SetBotAliasStatus sets the BotAliasStatus field's value.
func (s *DeleteBotAliasOutput) SetBotAliasStatus(v string) *DeleteBotAliasOutput {
	s.BotAliasStatus = &v
	return s
}

// SetBotId sets the BotId field's value.
func (s *DeleteBotAliasOutput) SetBotId(v string) *DeleteBotAliasOutput {
	s.BotId = &v
	return s
}

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

	// The identifier of the bot to delete.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// When true, Amazon Lex doesn't check to see if another resource, such as an
	// alias, is using the bot before it is deleted.
	SkipResourceInUseCheck *bool `location:"querystring" locationName:"skipResourceInUseCheck" type:"boolean"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DeleteBotInput) SetBotId(v string) *DeleteBotInput {
	s.BotId = &v
	return s
}

// SetSkipResourceInUseCheck sets the SkipResourceInUseCheck field's value.
func (s *DeleteBotInput) SetSkipResourceInUseCheck(v bool) *DeleteBotInput {
	s.SkipResourceInUseCheck = &v
	return s
}

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

	// The unique identifier of the bot that contains the locale.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that contains the locale.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The identifier of the language and locale that will be deleted. The string
	// must match one of the supported locales. For more information, see Supported
	// languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DeleteBotLocaleInput) SetBotId(v string) *DeleteBotLocaleInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DeleteBotLocaleInput) SetBotVersion(v string) *DeleteBotLocaleInput {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DeleteBotLocaleInput) SetLocaleId(v string) *DeleteBotLocaleInput {
	s.LocaleId = &v
	return s
}

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

	// The identifier of the bot that contained the deleted locale.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The status of deleting the bot locale. The locale first enters the Deleting
	// status. Once the locale is deleted it no longer appears in the list of locales
	// for the bot.
	BotLocaleStatus *string `locationName:"botLocaleStatus" type:"string" enum:"BotLocaleStatus"`

	// The version of the bot that contained the deleted locale.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// The language and locale of the deleted locale.
	LocaleId *string `locationName:"localeId" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DeleteBotLocaleOutput) SetBotId(v string) *DeleteBotLocaleOutput {
	s.BotId = &v
	return s
}

// SetBotLocaleStatus sets the BotLocaleStatus field's value.
func (s *DeleteBotLocaleOutput) SetBotLocaleStatus(v string) *DeleteBotLocaleOutput {
	s.BotLocaleStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DeleteBotLocaleOutput) SetBotVersion(v string) *DeleteBotLocaleOutput {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DeleteBotLocaleOutput) SetLocaleId(v string) *DeleteBotLocaleOutput {
	s.LocaleId = &v
	return s
}

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

	// The unique identifier of the bot that Amazon Lex is deleting.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The current status of the bot. The status is Deleting while the bot and its
	// associated resources are being deleted.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DeleteBotOutput) SetBotId(v string) *DeleteBotOutput {
	s.BotId = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *DeleteBotOutput) SetBotStatus(v string) *DeleteBotOutput {
	s.BotStatus = &v
	return s
}

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

	// The identifier of the bot that contains the version.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot to delete.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// By default, the DeleteBotVersion operations throws a ResourceInUseException
	// exception if you try to delete a bot version that has an alias pointing at
	// it. Set the skipResourceInUseCheck parameter to true to skip this check and
	// remove the version even if an alias points to it.
	SkipResourceInUseCheck *bool `location:"querystring" locationName:"skipResourceInUseCheck" type:"boolean"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DeleteBotVersionInput) SetBotId(v string) *DeleteBotVersionInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DeleteBotVersionInput) SetBotVersion(v string) *DeleteBotVersionInput {
	s.BotVersion = &v
	return s
}

// SetSkipResourceInUseCheck sets the SkipResourceInUseCheck field's value.
func (s *DeleteBotVersionInput) SetSkipResourceInUseCheck(v bool) *DeleteBotVersionInput {
	s.SkipResourceInUseCheck = &v
	return s
}

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

	// The identifier of the bot that is being deleted.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The current status of the bot.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`

	// The version of the bot that is being deleted.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DeleteBotVersionOutput) SetBotId(v string) *DeleteBotVersionOutput {
	s.BotId = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *DeleteBotVersionOutput) SetBotStatus(v string) *DeleteBotVersionOutput {
	s.BotStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DeleteBotVersionOutput) SetBotVersion(v string) *DeleteBotVersionOutput {
	s.BotVersion = &v
	return s
}

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

	// The unique identifier of the export to delete.
	//
	// ExportId is a required field
	ExportId *string `location:"uri" locationName:"exportId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetExportId sets the ExportId field's value.
func (s *DeleteExportInput) SetExportId(v string) *DeleteExportInput {
	s.ExportId = &v
	return s
}

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

	// The unique identifier of the deleted export.
	ExportId *string `locationName:"exportId" min:"10" type:"string"`

	// The current status of the deletion. When the deletion is complete, the export
	// will no longer be returned by the operation and calls to the with the export
	// identifier will fail.
	ExportStatus *string `locationName:"exportStatus" type:"string" enum:"ExportStatus"`
}

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

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

// SetExportId sets the ExportId field's value.
func (s *DeleteExportOutput) SetExportId(v string) *DeleteExportOutput {
	s.ExportId = &v
	return s
}

// SetExportStatus sets the ExportStatus field's value.
func (s *DeleteExportOutput) SetExportStatus(v string) *DeleteExportOutput {
	s.ExportStatus = &v
	return s
}

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

	// The unique identifier of the import to delete.
	//
	// ImportId is a required field
	ImportId *string `location:"uri" locationName:"importId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetImportId sets the ImportId field's value.
func (s *DeleteImportInput) SetImportId(v string) *DeleteImportInput {
	s.ImportId = &v
	return s
}

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

	// The unique identifier of the deleted import.
	ImportId *string `locationName:"importId" min:"10" type:"string"`

	// The current status of the deletion. When the deletion is complete, the import
	// will no longer be returned by the operation and calls to the with the import
	// identifier will fail.
	ImportStatus *string `locationName:"importStatus" type:"string" enum:"ImportStatus"`
}

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

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

// SetImportId sets the ImportId field's value.
func (s *DeleteImportOutput) SetImportId(v string) *DeleteImportOutput {
	s.ImportId = &v
	return s
}

// SetImportStatus sets the ImportStatus field's value.
func (s *DeleteImportOutput) SetImportStatus(v string) *DeleteImportOutput {
	s.ImportStatus = &v
	return s
}

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

	// The identifier of the bot associated with the intent.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot associated with the intent.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The unique identifier of the intent to delete.
	//
	// IntentId is a required field
	IntentId *string `location:"uri" locationName:"intentId" min:"10" type:"string" required:"true"`

	// The identifier of the language and locale where the bot will be deleted.
	// The string must match one of the supported locales. For more information,
	// see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DeleteIntentInput) SetBotId(v string) *DeleteIntentInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DeleteIntentInput) SetBotVersion(v string) *DeleteIntentInput {
	s.BotVersion = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *DeleteIntentInput) SetIntentId(v string) *DeleteIntentInput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DeleteIntentInput) SetLocaleId(v string) *DeleteIntentInput {
	s.LocaleId = &v
	return s
}

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

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

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

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

	// The identifier of the revision to edit. If this ID doesn't match the current
	// revision number, Amazon Lex returns an exception
	//
	// If you don't specify a revision ID, Amazon Lex will delete the current policy.
	ExpectedRevisionId *string `location:"querystring" locationName:"expectedRevisionId" min:"1" type:"string"`

	// The Amazon Resource Name (ARN) of the bot or bot alias that has the resource
	// policy attached.
	//
	// ResourceArn is a required field
	ResourceArn *string `location:"uri" locationName:"resourceArn" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetExpectedRevisionId sets the ExpectedRevisionId field's value.
func (s *DeleteResourcePolicyInput) SetExpectedRevisionId(v string) *DeleteResourcePolicyInput {
	s.ExpectedRevisionId = &v
	return s
}

// SetResourceArn sets the ResourceArn field's value.
func (s *DeleteResourcePolicyInput) SetResourceArn(v string) *DeleteResourcePolicyInput {
	s.ResourceArn = &v
	return s
}

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

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy was deleted from.
	ResourceArn *string `locationName:"resourceArn" min:"1" type:"string"`

	// The current revision of the resource policy. Use the revision ID to make
	// sure that you are updating the most current version of a resource policy
	// when you add a policy statement to a resource, delete a resource, or update
	// a resource.
	RevisionId *string `locationName:"revisionId" min:"1" type:"string"`
}

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

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

// SetResourceArn sets the ResourceArn field's value.
func (s *DeleteResourcePolicyOutput) SetResourceArn(v string) *DeleteResourcePolicyOutput {
	s.ResourceArn = &v
	return s
}

// SetRevisionId sets the RevisionId field's value.
func (s *DeleteResourcePolicyOutput) SetRevisionId(v string) *DeleteResourcePolicyOutput {
	s.RevisionId = &v
	return s
}

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

	// The identifier of the revision of the policy to delete the statement from.
	// If this revision ID doesn't match the current revision ID, Amazon Lex throws
	// an exception.
	//
	// If you don't specify a revision, Amazon Lex removes the current contents
	// of the statement.
	ExpectedRevisionId *string `location:"querystring" locationName:"expectedRevisionId" min:"1" type:"string"`

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy is attached to.
	//
	// ResourceArn is a required field
	ResourceArn *string `location:"uri" locationName:"resourceArn" min:"1" type:"string" required:"true"`

	// The name of the statement (SID) to delete from the policy.
	//
	// StatementId is a required field
	StatementId *string `location:"uri" locationName:"statementId" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetExpectedRevisionId sets the ExpectedRevisionId field's value.
func (s *DeleteResourcePolicyStatementInput) SetExpectedRevisionId(v string) *DeleteResourcePolicyStatementInput {
	s.ExpectedRevisionId = &v
	return s
}

// SetResourceArn sets the ResourceArn field's value.
func (s *DeleteResourcePolicyStatementInput) SetResourceArn(v string) *DeleteResourcePolicyStatementInput {
	s.ResourceArn = &v
	return s
}

// SetStatementId sets the StatementId field's value.
func (s *DeleteResourcePolicyStatementInput) SetStatementId(v string) *DeleteResourcePolicyStatementInput {
	s.StatementId = &v
	return s
}

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

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy statement was removed from.
	ResourceArn *string `locationName:"resourceArn" min:"1" type:"string"`

	// The current revision of the resource policy. Use the revision ID to make
	// sure that you are updating the most current version of a resource policy
	// when you add a policy statement to a resource, delete a resource, or update
	// a resource.
	RevisionId *string `locationName:"revisionId" min:"1" type:"string"`
}

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

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

// SetResourceArn sets the ResourceArn field's value.
func (s *DeleteResourcePolicyStatementOutput) SetResourceArn(v string) *DeleteResourcePolicyStatementOutput {
	s.ResourceArn = &v
	return s
}

// SetRevisionId sets the RevisionId field's value.
func (s *DeleteResourcePolicyStatementOutput) SetRevisionId(v string) *DeleteResourcePolicyStatementOutput {
	s.RevisionId = &v
	return s
}

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

	// The identifier of the bot associated with the slot to delete.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot associated with the slot to delete.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The identifier of the intent associated with the slot.
	//
	// IntentId is a required field
	IntentId *string `location:"uri" locationName:"intentId" min:"10" type:"string" required:"true"`

	// The identifier of the language and locale that the slot will be deleted from.
	// The string must match one of the supported locales. For more information,
	// see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The identifier of the slot to delete.
	//
	// SlotId is a required field
	SlotId *string `location:"uri" locationName:"slotId" min:"10" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteSlotInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "DeleteSlotInput"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion == nil {
		invalidParams.Add(request.NewErrParamRequired("BotVersion"))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.IntentId == nil {
		invalidParams.Add(request.NewErrParamRequired("IntentId"))
	}
	if s.IntentId != nil && len(*s.IntentId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("IntentId", 10))
	}
	if s.LocaleId == nil {
		invalidParams.Add(request.NewErrParamRequired("LocaleId"))
	}
	if s.LocaleId != nil && len(*s.LocaleId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("LocaleId", 1))
	}
	if s.SlotId == nil {
		invalidParams.Add(request.NewErrParamRequired("SlotId"))
	}
	if s.SlotId != nil && len(*s.SlotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("SlotId", 10))
	}

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

// SetBotId sets the BotId field's value.
func (s *DeleteSlotInput) SetBotId(v string) *DeleteSlotInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DeleteSlotInput) SetBotVersion(v string) *DeleteSlotInput {
	s.BotVersion = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *DeleteSlotInput) SetIntentId(v string) *DeleteSlotInput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DeleteSlotInput) SetLocaleId(v string) *DeleteSlotInput {
	s.LocaleId = &v
	return s
}

// SetSlotId sets the SlotId field's value.
func (s *DeleteSlotInput) SetSlotId(v string) *DeleteSlotInput {
	s.SlotId = &v
	return s
}

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

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

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

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

	// The identifier of the bot associated with the slot type.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot associated with the slot type.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The identifier of the language and locale that the slot type will be deleted
	// from. The string must match one of the supported locales. For more information,
	// see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// By default, the DeleteSlotType operations throws a ResourceInUseException
	// exception if you try to delete a slot type used by a slot. Set the skipResourceInUseCheck
	// parameter to true to skip this check and remove the slot type even if a slot
	// uses it.
	SkipResourceInUseCheck *bool `location:"querystring" locationName:"skipResourceInUseCheck" type:"boolean"`

	// The identifier of the slot type to delete.
	//
	// SlotTypeId is a required field
	SlotTypeId *string `location:"uri" locationName:"slotTypeId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DeleteSlotTypeInput) SetBotId(v string) *DeleteSlotTypeInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DeleteSlotTypeInput) SetBotVersion(v string) *DeleteSlotTypeInput {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DeleteSlotTypeInput) SetLocaleId(v string) *DeleteSlotTypeInput {
	s.LocaleId = &v
	return s
}

// SetSkipResourceInUseCheck sets the SkipResourceInUseCheck field's value.
func (s *DeleteSlotTypeInput) SetSkipResourceInUseCheck(v bool) *DeleteSlotTypeInput {
	s.SkipResourceInUseCheck = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *DeleteSlotTypeInput) SetSlotTypeId(v string) *DeleteSlotTypeInput {
	s.SlotTypeId = &v
	return s
}

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

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

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

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

	// The identifier of the bot alias to describe.
	//
	// BotAliasId is a required field
	BotAliasId *string `location:"uri" locationName:"botAliasId" min:"10" type:"string" required:"true"`

	// The identifier of the bot associated with the bot alias to describe.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetBotAliasId sets the BotAliasId field's value.
func (s *DescribeBotAliasInput) SetBotAliasId(v string) *DescribeBotAliasInput {
	s.BotAliasId = &v
	return s
}

// SetBotId sets the BotId field's value.
func (s *DescribeBotAliasInput) SetBotId(v string) *DescribeBotAliasInput {
	s.BotId = &v
	return s
}

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

	// A list of events that affect a bot alias. For example, an event is recorded
	// when the version that the alias points to changes.
	BotAliasHistoryEvents []*BotAliasHistoryEvent `locationName:"botAliasHistoryEvents" type:"list"`

	// The identifier of the bot alias.
	BotAliasId *string `locationName:"botAliasId" min:"10" type:"string"`

	// The locale settings that are unique to the alias.
	BotAliasLocaleSettings map[string]*BotAliasLocaleSettings `locationName:"botAliasLocaleSettings" min:"1" type:"map"`

	// The name of the bot alias.
	BotAliasName *string `locationName:"botAliasName" min:"1" type:"string"`

	// The current status of the alias. When the alias is Available, the alias is
	// ready for use with your bot.
	BotAliasStatus *string `locationName:"botAliasStatus" type:"string" enum:"BotAliasStatus"`

	// The identifier of the bot associated with the bot alias.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot associated with the bot alias.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// Specifics of how Amazon Lex logs text and audio conversations with the bot
	// associated with the alias.
	ConversationLogSettings *ConversationLogSettings `locationName:"conversationLogSettings" type:"structure"`

	// A timestamp of the date and time that the alias was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description of the bot alias.
	Description *string `locationName:"description" type:"string"`

	// A timestamp of the date and time that the alias was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// Determines whether Amazon Lex will use Amazon Comprehend to detect the sentiment
	// of user utterances.
	SentimentAnalysisSettings *SentimentAnalysisSettings `locationName:"sentimentAnalysisSettings" type:"structure"`
}

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

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

// SetBotAliasHistoryEvents sets the BotAliasHistoryEvents field's value.
func (s *DescribeBotAliasOutput) SetBotAliasHistoryEvents(v []*BotAliasHistoryEvent) *DescribeBotAliasOutput {
	s.BotAliasHistoryEvents = v
	return s
}

// SetBotAliasId sets the BotAliasId field's value.
func (s *DescribeBotAliasOutput) SetBotAliasId(v string) *DescribeBotAliasOutput {
	s.BotAliasId = &v
	return s
}

// SetBotAliasLocaleSettings sets the BotAliasLocaleSettings field's value.
func (s *DescribeBotAliasOutput) SetBotAliasLocaleSettings(v map[string]*BotAliasLocaleSettings) *DescribeBotAliasOutput {
	s.BotAliasLocaleSettings = v
	return s
}

// SetBotAliasName sets the BotAliasName field's value.
func (s *DescribeBotAliasOutput) SetBotAliasName(v string) *DescribeBotAliasOutput {
	s.BotAliasName = &v
	return s
}

// SetBotAliasStatus sets the BotAliasStatus field's value.
func (s *DescribeBotAliasOutput) SetBotAliasStatus(v string) *DescribeBotAliasOutput {
	s.BotAliasStatus = &v
	return s
}

// SetBotId sets the BotId field's value.
func (s *DescribeBotAliasOutput) SetBotId(v string) *DescribeBotAliasOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeBotAliasOutput) SetBotVersion(v string) *DescribeBotAliasOutput {
	s.BotVersion = &v
	return s
}

// SetConversationLogSettings sets the ConversationLogSettings field's value.
func (s *DescribeBotAliasOutput) SetConversationLogSettings(v *ConversationLogSettings) *DescribeBotAliasOutput {
	s.ConversationLogSettings = v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeBotAliasOutput) SetCreationDateTime(v time.Time) *DescribeBotAliasOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *DescribeBotAliasOutput) SetDescription(v string) *DescribeBotAliasOutput {
	s.Description = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *DescribeBotAliasOutput) SetLastUpdatedDateTime(v time.Time) *DescribeBotAliasOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetSentimentAnalysisSettings sets the SentimentAnalysisSettings field's value.
func (s *DescribeBotAliasOutput) SetSentimentAnalysisSettings(v *SentimentAnalysisSettings) *DescribeBotAliasOutput {
	s.SentimentAnalysisSettings = v
	return s
}

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

	// The unique identifier of the bot to describe.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeBotInput) SetBotId(v string) *DescribeBotInput {
	s.BotId = &v
	return s
}

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

	// The identifier of the bot associated with the locale.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The identifier of the version of the bot associated with the locale.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// The unique identifier of the locale to describe. The string must match one
	// of the supported locales. For more information, see Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeBotLocaleInput) SetBotId(v string) *DescribeBotLocaleInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeBotLocaleInput) SetBotVersion(v string) *DescribeBotLocaleInput {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DescribeBotLocaleInput) SetLocaleId(v string) *DescribeBotLocaleInput {
	s.LocaleId = &v
	return s
}

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

	// The identifier of the bot associated with the locale.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// History of changes, such as when a locale is used in an alias, that have
	// taken place for the locale.
	BotLocaleHistoryEvents []*BotLocaleHistoryEvent `locationName:"botLocaleHistoryEvents" type:"list"`

	// The status of the bot. If the status is Failed, the reasons for the failure
	// are listed in the failureReasons field.
	BotLocaleStatus *string `locationName:"botLocaleStatus" type:"string" enum:"BotLocaleStatus"`

	// The identifier of the version of the bot associated with the locale.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// The date and time that the locale was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description of the locale.
	Description *string `locationName:"description" type:"string"`

	// if botLocaleStatus is Failed, Amazon Lex explains why it failed to build
	// the bot.
	FailureReasons []*string `locationName:"failureReasons" type:"list"`

	// The number of intents defined for the locale.
	IntentsCount *int64 `locationName:"intentsCount" type:"integer"`

	// The date and time that the locale was last submitted for building.
	LastBuildSubmittedDateTime *time.Time `locationName:"lastBuildSubmittedDateTime" type:"timestamp"`

	// The date and time that the locale was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The unique identifier of the described locale.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The name of the locale.
	LocaleName *string `locationName:"localeName" type:"string"`

	// The confidence threshold where Amazon Lex inserts the AMAZON.FallbackIntent
	// and AMAZON.KendraSearchIntent intents in the list of possible intents for
	// an utterance.
	NluIntentConfidenceThreshold *float64 `locationName:"nluIntentConfidenceThreshold" type:"double"`

	// The number of slot types defined for the locale.
	SlotTypesCount *int64 `locationName:"slotTypesCount" type:"integer"`

	// The Amazon Polly voice Amazon Lex uses for voice interaction with the user.
	VoiceSettings *VoiceSettings `locationName:"voiceSettings" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeBotLocaleOutput) SetBotId(v string) *DescribeBotLocaleOutput {
	s.BotId = &v
	return s
}

// SetBotLocaleHistoryEvents sets the BotLocaleHistoryEvents field's value.
func (s *DescribeBotLocaleOutput) SetBotLocaleHistoryEvents(v []*BotLocaleHistoryEvent) *DescribeBotLocaleOutput {
	s.BotLocaleHistoryEvents = v
	return s
}

// SetBotLocaleStatus sets the BotLocaleStatus field's value.
func (s *DescribeBotLocaleOutput) SetBotLocaleStatus(v string) *DescribeBotLocaleOutput {
	s.BotLocaleStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeBotLocaleOutput) SetBotVersion(v string) *DescribeBotLocaleOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeBotLocaleOutput) SetCreationDateTime(v time.Time) *DescribeBotLocaleOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *DescribeBotLocaleOutput) SetDescription(v string) *DescribeBotLocaleOutput {
	s.Description = &v
	return s
}

// SetFailureReasons sets the FailureReasons field's value.
func (s *DescribeBotLocaleOutput) SetFailureReasons(v []*string) *DescribeBotLocaleOutput {
	s.FailureReasons = v
	return s
}

// SetIntentsCount sets the IntentsCount field's value.
func (s *DescribeBotLocaleOutput) SetIntentsCount(v int64) *DescribeBotLocaleOutput {
	s.IntentsCount = &v
	return s
}

// SetLastBuildSubmittedDateTime sets the LastBuildSubmittedDateTime field's value.
func (s *DescribeBotLocaleOutput) SetLastBuildSubmittedDateTime(v time.Time) *DescribeBotLocaleOutput {
	s.LastBuildSubmittedDateTime = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *DescribeBotLocaleOutput) SetLastUpdatedDateTime(v time.Time) *DescribeBotLocaleOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DescribeBotLocaleOutput) SetLocaleId(v string) *DescribeBotLocaleOutput {
	s.LocaleId = &v
	return s
}

// SetLocaleName sets the LocaleName field's value.
func (s *DescribeBotLocaleOutput) SetLocaleName(v string) *DescribeBotLocaleOutput {
	s.LocaleName = &v
	return s
}

// SetNluIntentConfidenceThreshold sets the NluIntentConfidenceThreshold field's value.
func (s *DescribeBotLocaleOutput) SetNluIntentConfidenceThreshold(v float64) *DescribeBotLocaleOutput {
	s.NluIntentConfidenceThreshold = &v
	return s
}

// SetSlotTypesCount sets the SlotTypesCount field's value.
func (s *DescribeBotLocaleOutput) SetSlotTypesCount(v int64) *DescribeBotLocaleOutput {
	s.SlotTypesCount = &v
	return s
}

// SetVoiceSettings sets the VoiceSettings field's value.
func (s *DescribeBotLocaleOutput) SetVoiceSettings(v *VoiceSettings) *DescribeBotLocaleOutput {
	s.VoiceSettings = v
	return s
}

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

	// The unique identifier of the bot.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The name of the bot.
	BotName *string `locationName:"botName" min:"1" type:"string"`

	// The current status of the bot. When the status is Available the bot is ready
	// to be used in conversations with users.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`

	// A timestamp of the date and time that the bot was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// Settings for managing data privacy of the bot and its conversations with
	// users.
	DataPrivacy *DataPrivacy `locationName:"dataPrivacy" type:"structure"`

	// The description of the bot.
	Description *string `locationName:"description" type:"string"`

	// The maximum time in seconds that Amazon Lex retains the data gathered in
	// a conversation.
	IdleSessionTTLInSeconds *int64 `locationName:"idleSessionTTLInSeconds" min:"60" type:"integer"`

	// A timestamp of the date and time that the bot was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The Amazon Resource Name (ARN) of an IAM role that has permission to access
	// the bot.
	RoleArn *string `locationName:"roleArn" min:"32" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeBotOutput) SetBotId(v string) *DescribeBotOutput {
	s.BotId = &v
	return s
}

// SetBotName sets the BotName field's value.
func (s *DescribeBotOutput) SetBotName(v string) *DescribeBotOutput {
	s.BotName = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *DescribeBotOutput) SetBotStatus(v string) *DescribeBotOutput {
	s.BotStatus = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeBotOutput) SetCreationDateTime(v time.Time) *DescribeBotOutput {
	s.CreationDateTime = &v
	return s
}

// SetDataPrivacy sets the DataPrivacy field's value.
func (s *DescribeBotOutput) SetDataPrivacy(v *DataPrivacy) *DescribeBotOutput {
	s.DataPrivacy = v
	return s
}

// SetDescription sets the Description field's value.
func (s *DescribeBotOutput) SetDescription(v string) *DescribeBotOutput {
	s.Description = &v
	return s
}

// SetIdleSessionTTLInSeconds sets the IdleSessionTTLInSeconds field's value.
func (s *DescribeBotOutput) SetIdleSessionTTLInSeconds(v int64) *DescribeBotOutput {
	s.IdleSessionTTLInSeconds = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *DescribeBotOutput) SetLastUpdatedDateTime(v time.Time) *DescribeBotOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetRoleArn sets the RoleArn field's value.
func (s *DescribeBotOutput) SetRoleArn(v string) *DescribeBotOutput {
	s.RoleArn = &v
	return s
}

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

	// The identifier of the bot containing the version to return metadata for.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot to return metadata for.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeBotVersionInput) SetBotId(v string) *DescribeBotVersionInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeBotVersionInput) SetBotVersion(v string) *DescribeBotVersionInput {
	s.BotVersion = &v
	return s
}

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

	// The identifier of the bot that contains the version.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The name of the bot that contains the version.
	BotName *string `locationName:"botName" min:"1" type:"string"`

	// The current status of the bot. When the status is Available, the bot version
	// is ready for use.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`

	// The version of the bot to describe.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// A timestamp of the date and time that the bot version was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// Data privacy settings for the bot version.
	DataPrivacy *DataPrivacy `locationName:"dataPrivacy" type:"structure"`

	// The description specified for the bot.
	Description *string `locationName:"description" type:"string"`

	// If the botStatus is Failed, this contains a list of reasons that the version
	// couldn't be built.
	FailureReasons []*string `locationName:"failureReasons" type:"list"`

	// The number of seconds that a session with the bot remains active before it
	// is discarded by Amazon Lex.
	IdleSessionTTLInSeconds *int64 `locationName:"idleSessionTTLInSeconds" min:"60" type:"integer"`

	// The Amazon Resource Name (ARN) of an IAM role that has permission to access
	// the bot version.
	RoleArn *string `locationName:"roleArn" min:"32" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeBotVersionOutput) SetBotId(v string) *DescribeBotVersionOutput {
	s.BotId = &v
	return s
}

// SetBotName sets the BotName field's value.
func (s *DescribeBotVersionOutput) SetBotName(v string) *DescribeBotVersionOutput {
	s.BotName = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *DescribeBotVersionOutput) SetBotStatus(v string) *DescribeBotVersionOutput {
	s.BotStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeBotVersionOutput) SetBotVersion(v string) *DescribeBotVersionOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeBotVersionOutput) SetCreationDateTime(v time.Time) *DescribeBotVersionOutput {
	s.CreationDateTime = &v
	return s
}

// SetDataPrivacy sets the DataPrivacy field's value.
func (s *DescribeBotVersionOutput) SetDataPrivacy(v *DataPrivacy) *DescribeBotVersionOutput {
	s.DataPrivacy = v
	return s
}

// SetDescription sets the Description field's value.
func (s *DescribeBotVersionOutput) SetDescription(v string) *DescribeBotVersionOutput {
	s.Description = &v
	return s
}

// SetFailureReasons sets the FailureReasons field's value.
func (s *DescribeBotVersionOutput) SetFailureReasons(v []*string) *DescribeBotVersionOutput {
	s.FailureReasons = v
	return s
}

// SetIdleSessionTTLInSeconds sets the IdleSessionTTLInSeconds field's value.
func (s *DescribeBotVersionOutput) SetIdleSessionTTLInSeconds(v int64) *DescribeBotVersionOutput {
	s.IdleSessionTTLInSeconds = &v
	return s
}

// SetRoleArn sets the RoleArn field's value.
func (s *DescribeBotVersionOutput) SetRoleArn(v string) *DescribeBotVersionOutput {
	s.RoleArn = &v
	return s
}

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

	// The unique identifier of the export to describe.
	//
	// ExportId is a required field
	ExportId *string `location:"uri" locationName:"exportId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetExportId sets the ExportId field's value.
func (s *DescribeExportInput) SetExportId(v string) *DescribeExportInput {
	s.ExportId = &v
	return s
}

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

	// The date and time that the export was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// A pre-signed S3 URL that points to the bot or bot locale archive. The URL
	// is only available for 5 minutes after calling the DescribeExport operation.
	DownloadUrl *string `locationName:"downloadUrl" min:"1" type:"string"`

	// The unique identifier of the described export.
	ExportId *string `locationName:"exportId" min:"10" type:"string"`

	// The status of the export. When the status is Complete the export archive
	// file is available for download.
	ExportStatus *string `locationName:"exportStatus" type:"string" enum:"ExportStatus"`

	// If the exportStatus is failed, contains one or more reasons why the export
	// could not be completed.
	FailureReasons []*string `locationName:"failureReasons" type:"list"`

	// The file format used in the files that describe the bot or bot locale.
	FileFormat *string `locationName:"fileFormat" type:"string" enum:"ImportExportFileFormat"`

	// The last date and time that the export was updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The bot, bot ID, and optional locale ID of the exported bot or bot locale.
	ResourceSpecification *ExportResourceSpecification `locationName:"resourceSpecification" type:"structure"`
}

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

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

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeExportOutput) SetCreationDateTime(v time.Time) *DescribeExportOutput {
	s.CreationDateTime = &v
	return s
}

// SetDownloadUrl sets the DownloadUrl field's value.
func (s *DescribeExportOutput) SetDownloadUrl(v string) *DescribeExportOutput {
	s.DownloadUrl = &v
	return s
}

// SetExportId sets the ExportId field's value.
func (s *DescribeExportOutput) SetExportId(v string) *DescribeExportOutput {
	s.ExportId = &v
	return s
}

// SetExportStatus sets the ExportStatus field's value.
func (s *DescribeExportOutput) SetExportStatus(v string) *DescribeExportOutput {
	s.ExportStatus = &v
	return s
}

// SetFailureReasons sets the FailureReasons field's value.
func (s *DescribeExportOutput) SetFailureReasons(v []*string) *DescribeExportOutput {
	s.FailureReasons = v
	return s
}

// SetFileFormat sets the FileFormat field's value.
func (s *DescribeExportOutput) SetFileFormat(v string) *DescribeExportOutput {
	s.FileFormat = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *DescribeExportOutput) SetLastUpdatedDateTime(v time.Time) *DescribeExportOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetResourceSpecification sets the ResourceSpecification field's value.
func (s *DescribeExportOutput) SetResourceSpecification(v *ExportResourceSpecification) *DescribeExportOutput {
	s.ResourceSpecification = v
	return s
}

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

	// The unique identifier of the import to describe.
	//
	// ImportId is a required field
	ImportId *string `location:"uri" locationName:"importId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetImportId sets the ImportId field's value.
func (s *DescribeImportInput) SetImportId(v string) *DescribeImportInput {
	s.ImportId = &v
	return s
}

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

	// The date and time that the import was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// If the importStatus field is Failed, this provides one or more reasons for
	// the failture.
	FailureReasons []*string `locationName:"failureReasons" type:"list"`

	// The unique identifier of the described import.
	ImportId *string `locationName:"importId" min:"10" type:"string"`

	// The status of the import process. When the status is Completed the resource
	// is imported and ready for use.
	ImportStatus *string `locationName:"importStatus" type:"string" enum:"ImportStatus"`

	// The unique identifier that Amazon Lex assigned to the resource created by
	// the import.
	ImportedResourceId *string `locationName:"importedResourceId" min:"5" type:"string"`

	// The name of the imported resource.
	ImportedResourceName *string `locationName:"importedResourceName" min:"1" type:"string"`

	// The date and time that the import was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The strategy used when there was a name conflict between the imported resource
	// and an existing resource. When the merge strategy is FailOnConflict existing
	// resources are not overwritten and the import fails.
	MergeStrategy *string `locationName:"mergeStrategy" type:"string" enum:"MergeStrategy"`

	// The specifications of the imported bot or bot locale.
	ResourceSpecification *ImportResourceSpecification `locationName:"resourceSpecification" type:"structure"`
}

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

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

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeImportOutput) SetCreationDateTime(v time.Time) *DescribeImportOutput {
	s.CreationDateTime = &v
	return s
}

// SetFailureReasons sets the FailureReasons field's value.
func (s *DescribeImportOutput) SetFailureReasons(v []*string) *DescribeImportOutput {
	s.FailureReasons = v
	return s
}

// SetImportId sets the ImportId field's value.
func (s *DescribeImportOutput) SetImportId(v string) *DescribeImportOutput {
	s.ImportId = &v
	return s
}

// SetImportStatus sets the ImportStatus field's value.
func (s *DescribeImportOutput) SetImportStatus(v string) *DescribeImportOutput {
	s.ImportStatus = &v
	return s
}

// SetImportedResourceId sets the ImportedResourceId field's value.
func (s *DescribeImportOutput) SetImportedResourceId(v string) *DescribeImportOutput {
	s.ImportedResourceId = &v
	return s
}

// SetImportedResourceName sets the ImportedResourceName field's value.
func (s *DescribeImportOutput) SetImportedResourceName(v string) *DescribeImportOutput {
	s.ImportedResourceName = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *DescribeImportOutput) SetLastUpdatedDateTime(v time.Time) *DescribeImportOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetMergeStrategy sets the MergeStrategy field's value.
func (s *DescribeImportOutput) SetMergeStrategy(v string) *DescribeImportOutput {
	s.MergeStrategy = &v
	return s
}

// SetResourceSpecification sets the ResourceSpecification field's value.
func (s *DescribeImportOutput) SetResourceSpecification(v *ImportResourceSpecification) *DescribeImportOutput {
	s.ResourceSpecification = v
	return s
}

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

	// The identifier of the bot associated with the intent.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot associated with the intent.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// The identifier of the intent to describe.
	//
	// IntentId is a required field
	IntentId *string `location:"uri" locationName:"intentId" min:"10" type:"string" required:"true"`

	// The identifier of the language and locale of the intent to describe. The
	// string must match one of the supported locales. For more information, see
	// Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeIntentInput) SetBotId(v string) *DescribeIntentInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeIntentInput) SetBotVersion(v string) *DescribeIntentInput {
	s.BotVersion = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *DescribeIntentInput) SetIntentId(v string) *DescribeIntentInput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DescribeIntentInput) SetLocaleId(v string) *DescribeIntentInput {
	s.LocaleId = &v
	return s
}

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

	// The identifier of the bot associated with the intent.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot associated with the intent.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// A timestamp of the date and time that the intent was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description of the intent.
	Description *string `locationName:"description" type:"string"`

	// The Lambda function called during each turn of a conversation with the intent.
	DialogCodeHook *DialogCodeHookSettings `locationName:"dialogCodeHook" type:"structure"`

	// The Lambda function called when the intent is complete and ready for fulfillment.
	FulfillmentCodeHook *FulfillmentCodeHookSettings `locationName:"fulfillmentCodeHook" type:"structure"`

	// A list of contexts that must be active for the intent to be considered for
	// sending to the user.
	InputContexts []*InputContext `locationName:"inputContexts" type:"list"`

	// The response that Amazon Lex sends to when the intent is closed.
	IntentClosingSetting *IntentClosingSetting `locationName:"intentClosingSetting" type:"structure"`

	// Prompts that Amazon Lex sends to the user to confirm completion of an intent.
	IntentConfirmationSetting *IntentConfirmationSetting `locationName:"intentConfirmationSetting" type:"structure"`

	// The unique identifier assigned to the intent when it was created.
	IntentId *string `locationName:"intentId" min:"10" type:"string"`

	// The name specified for the intent.
	IntentName *string `locationName:"intentName" min:"1" type:"string"`

	// Configuration information required to use the AMAZON.KendraSearchIntent intent.
	KendraConfiguration *KendraConfiguration `locationName:"kendraConfiguration" type:"structure"`

	// A timestamp of the date and time that the intent was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The language and locale specified for the intent.
	LocaleId *string `locationName:"localeId" type:"string"`

	// A list of contexts that are activated when the intent is fulfilled.
	OutputContexts []*OutputContext `locationName:"outputContexts" type:"list"`

	// The identifier of the built-in intent that this intent is derived from, if
	// any.
	ParentIntentSignature *string `locationName:"parentIntentSignature" type:"string"`

	// User utterances that trigger this intent.
	SampleUtterances []*SampleUtterance `locationName:"sampleUtterances" type:"list"`

	// The list that determines the priority that slots should be elicited from
	// the user.
	SlotPriorities []*SlotPriority `locationName:"slotPriorities" type:"list"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeIntentOutput) SetBotId(v string) *DescribeIntentOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeIntentOutput) SetBotVersion(v string) *DescribeIntentOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeIntentOutput) SetCreationDateTime(v time.Time) *DescribeIntentOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *DescribeIntentOutput) SetDescription(v string) *DescribeIntentOutput {
	s.Description = &v
	return s
}

// SetDialogCodeHook sets the DialogCodeHook field's value.
func (s *DescribeIntentOutput) SetDialogCodeHook(v *DialogCodeHookSettings) *DescribeIntentOutput {
	s.DialogCodeHook = v
	return s
}

// SetFulfillmentCodeHook sets the FulfillmentCodeHook field's value.
func (s *DescribeIntentOutput) SetFulfillmentCodeHook(v *FulfillmentCodeHookSettings) *DescribeIntentOutput {
	s.FulfillmentCodeHook = v
	return s
}

// SetInputContexts sets the InputContexts field's value.
func (s *DescribeIntentOutput) SetInputContexts(v []*InputContext) *DescribeIntentOutput {
	s.InputContexts = v
	return s
}

// SetIntentClosingSetting sets the IntentClosingSetting field's value.
func (s *DescribeIntentOutput) SetIntentClosingSetting(v *IntentClosingSetting) *DescribeIntentOutput {
	s.IntentClosingSetting = v
	return s
}

// SetIntentConfirmationSetting sets the IntentConfirmationSetting field's value.
func (s *DescribeIntentOutput) SetIntentConfirmationSetting(v *IntentConfirmationSetting) *DescribeIntentOutput {
	s.IntentConfirmationSetting = v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *DescribeIntentOutput) SetIntentId(v string) *DescribeIntentOutput {
	s.IntentId = &v
	return s
}

// SetIntentName sets the IntentName field's value.
func (s *DescribeIntentOutput) SetIntentName(v string) *DescribeIntentOutput {
	s.IntentName = &v
	return s
}

// SetKendraConfiguration sets the KendraConfiguration field's value.
func (s *DescribeIntentOutput) SetKendraConfiguration(v *KendraConfiguration) *DescribeIntentOutput {
	s.KendraConfiguration = v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *DescribeIntentOutput) SetLastUpdatedDateTime(v time.Time) *DescribeIntentOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DescribeIntentOutput) SetLocaleId(v string) *DescribeIntentOutput {
	s.LocaleId = &v
	return s
}

// SetOutputContexts sets the OutputContexts field's value.
func (s *DescribeIntentOutput) SetOutputContexts(v []*OutputContext) *DescribeIntentOutput {
	s.OutputContexts = v
	return s
}

// SetParentIntentSignature sets the ParentIntentSignature field's value.
func (s *DescribeIntentOutput) SetParentIntentSignature(v string) *DescribeIntentOutput {
	s.ParentIntentSignature = &v
	return s
}

// SetSampleUtterances sets the SampleUtterances field's value.
func (s *DescribeIntentOutput) SetSampleUtterances(v []*SampleUtterance) *DescribeIntentOutput {
	s.SampleUtterances = v
	return s
}

// SetSlotPriorities sets the SlotPriorities field's value.
func (s *DescribeIntentOutput) SetSlotPriorities(v []*SlotPriority) *DescribeIntentOutput {
	s.SlotPriorities = v
	return s
}

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

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy is attached to.
	//
	// ResourceArn is a required field
	ResourceArn *string `location:"uri" locationName:"resourceArn" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetResourceArn sets the ResourceArn field's value.
func (s *DescribeResourcePolicyInput) SetResourceArn(v string) *DescribeResourcePolicyInput {
	s.ResourceArn = &v
	return s
}

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

	// The JSON structure that contains the resource policy. For more information
	// about the contents of a JSON policy document, see IAM JSON policy reference
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html).
	Policy *string `locationName:"policy" min:"2" type:"string"`

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy is attached to.
	ResourceArn *string `locationName:"resourceArn" min:"1" type:"string"`

	// The current revision of the resource policy. Use the revision ID to make
	// sure that you are updating the most current version of a resource policy
	// when you add a policy statement to a resource, delete a resource, or update
	// a resource.
	RevisionId *string `locationName:"revisionId" min:"1" type:"string"`
}

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

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

// SetPolicy sets the Policy field's value.
func (s *DescribeResourcePolicyOutput) SetPolicy(v string) *DescribeResourcePolicyOutput {
	s.Policy = &v
	return s
}

// SetResourceArn sets the ResourceArn field's value.
func (s *DescribeResourcePolicyOutput) SetResourceArn(v string) *DescribeResourcePolicyOutput {
	s.ResourceArn = &v
	return s
}

// SetRevisionId sets the RevisionId field's value.
func (s *DescribeResourcePolicyOutput) SetRevisionId(v string) *DescribeResourcePolicyOutput {
	s.RevisionId = &v
	return s
}

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

	// The identifier of the bot associated with the slot.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot associated with the slot.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// The identifier of the intent that contains the slot.
	//
	// IntentId is a required field
	IntentId *string `location:"uri" locationName:"intentId" min:"10" type:"string" required:"true"`

	// The identifier of the language and locale of the slot to describe. The string
	// must match one of the supported locales. For more information, see Supported
	// languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The unique identifier for the slot.
	//
	// SlotId is a required field
	SlotId *string `location:"uri" locationName:"slotId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeSlotInput) SetBotId(v string) *DescribeSlotInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeSlotInput) SetBotVersion(v string) *DescribeSlotInput {
	s.BotVersion = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *DescribeSlotInput) SetIntentId(v string) *DescribeSlotInput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DescribeSlotInput) SetLocaleId(v string) *DescribeSlotInput {
	s.LocaleId = &v
	return s
}

// SetSlotId sets the SlotId field's value.
func (s *DescribeSlotInput) SetSlotId(v string) *DescribeSlotInput {
	s.SlotId = &v
	return s
}

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

	// The identifier of the bot associated with the slot.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot associated with the slot.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// A timestamp of the date and time that the slot was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description specified for the slot.
	Description *string `locationName:"description" type:"string"`

	// The identifier of the intent associated with the slot.
	IntentId *string `locationName:"intentId" min:"10" type:"string"`

	// A timestamp of the date and time that the slot was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The language and locale specified for the slot.
	LocaleId *string `locationName:"localeId" type:"string"`

	// Indicates whether the slot accepts multiple values in a single utterance.
	//
	// If the multipleValuesSetting is not set, the default value is false.
	MultipleValuesSetting *MultipleValuesSetting `locationName:"multipleValuesSetting" type:"structure"`

	// Whether slot values are shown in Amazon CloudWatch logs. If the value is
	// None, the actual value of the slot is shown in logs.
	ObfuscationSetting *ObfuscationSetting `locationName:"obfuscationSetting" type:"structure"`

	// The unique identifier generated for the slot.
	SlotId *string `locationName:"slotId" min:"10" type:"string"`

	// The name specified for the slot.
	SlotName *string `locationName:"slotName" min:"1" type:"string"`

	// The identifier of the slot type that determines the values entered into the
	// slot.
	SlotTypeId *string `locationName:"slotTypeId" min:"1" type:"string"`

	// Prompts that Amazon Lex uses to elicit a value for the slot.
	ValueElicitationSetting *SlotValueElicitationSetting `locationName:"valueElicitationSetting" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeSlotOutput) SetBotId(v string) *DescribeSlotOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeSlotOutput) SetBotVersion(v string) *DescribeSlotOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeSlotOutput) SetCreationDateTime(v time.Time) *DescribeSlotOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *DescribeSlotOutput) SetDescription(v string) *DescribeSlotOutput {
	s.Description = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *DescribeSlotOutput) SetIntentId(v string) *DescribeSlotOutput {
	s.IntentId = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *DescribeSlotOutput) SetLastUpdatedDateTime(v time.Time) *DescribeSlotOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DescribeSlotOutput) SetLocaleId(v string) *DescribeSlotOutput {
	s.LocaleId = &v
	return s
}

// SetMultipleValuesSetting sets the MultipleValuesSetting field's value.
func (s *DescribeSlotOutput) SetMultipleValuesSetting(v *MultipleValuesSetting) *DescribeSlotOutput {
	s.MultipleValuesSetting = v
	return s
}

// SetObfuscationSetting sets the ObfuscationSetting field's value.
func (s *DescribeSlotOutput) SetObfuscationSetting(v *ObfuscationSetting) *DescribeSlotOutput {
	s.ObfuscationSetting = v
	return s
}

// SetSlotId sets the SlotId field's value.
func (s *DescribeSlotOutput) SetSlotId(v string) *DescribeSlotOutput {
	s.SlotId = &v
	return s
}

// SetSlotName sets the SlotName field's value.
func (s *DescribeSlotOutput) SetSlotName(v string) *DescribeSlotOutput {
	s.SlotName = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *DescribeSlotOutput) SetSlotTypeId(v string) *DescribeSlotOutput {
	s.SlotTypeId = &v
	return s
}

// SetValueElicitationSetting sets the ValueElicitationSetting field's value.
func (s *DescribeSlotOutput) SetValueElicitationSetting(v *SlotValueElicitationSetting) *DescribeSlotOutput {
	s.ValueElicitationSetting = v
	return s
}

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

	// The identifier of the bot associated with the slot type.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot associated with the slot type.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// The identifier of the language and locale of the slot type to describe. The
	// string must match one of the supported locales. For more information, see
	// Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The identifier of the slot type.
	//
	// SlotTypeId is a required field
	SlotTypeId *string `location:"uri" locationName:"slotTypeId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeSlotTypeInput) SetBotId(v string) *DescribeSlotTypeInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeSlotTypeInput) SetBotVersion(v string) *DescribeSlotTypeInput {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DescribeSlotTypeInput) SetLocaleId(v string) *DescribeSlotTypeInput {
	s.LocaleId = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *DescribeSlotTypeInput) SetSlotTypeId(v string) *DescribeSlotTypeInput {
	s.SlotTypeId = &v
	return s
}

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

	// The identifier of the bot associated with the slot type.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot associated with the slot type.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// A timestamp of the date and time that the slot type was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The description specified for the slot type.
	Description *string `locationName:"description" type:"string"`

	// A timestamp of the date and time that the slot type was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The language and locale specified for the slot type.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The built in slot type used as a parent to this slot type.
	ParentSlotTypeSignature *string `locationName:"parentSlotTypeSignature" type:"string"`

	// The unique identifier for the slot type.
	SlotTypeId *string `locationName:"slotTypeId" min:"10" type:"string"`

	// The name specified for the slot type.
	SlotTypeName *string `locationName:"slotTypeName" min:"1" type:"string"`

	// The values that the slot type can take. Includes any synonyms for the slot
	// type values.
	SlotTypeValues []*SlotTypeValue `locationName:"slotTypeValues" min:"1" type:"list"`

	// The strategy that Amazon Lex uses to choose a value from a list of possible
	// values.
	ValueSelectionSetting *SlotValueSelectionSetting `locationName:"valueSelectionSetting" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *DescribeSlotTypeOutput) SetBotId(v string) *DescribeSlotTypeOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *DescribeSlotTypeOutput) SetBotVersion(v string) *DescribeSlotTypeOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *DescribeSlotTypeOutput) SetCreationDateTime(v time.Time) *DescribeSlotTypeOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *DescribeSlotTypeOutput) SetDescription(v string) *DescribeSlotTypeOutput {
	s.Description = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *DescribeSlotTypeOutput) SetLastUpdatedDateTime(v time.Time) *DescribeSlotTypeOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *DescribeSlotTypeOutput) SetLocaleId(v string) *DescribeSlotTypeOutput {
	s.LocaleId = &v
	return s
}

// SetParentSlotTypeSignature sets the ParentSlotTypeSignature field's value.
func (s *DescribeSlotTypeOutput) SetParentSlotTypeSignature(v string) *DescribeSlotTypeOutput {
	s.ParentSlotTypeSignature = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *DescribeSlotTypeOutput) SetSlotTypeId(v string) *DescribeSlotTypeOutput {
	s.SlotTypeId = &v
	return s
}

// SetSlotTypeName sets the SlotTypeName field's value.
func (s *DescribeSlotTypeOutput) SetSlotTypeName(v string) *DescribeSlotTypeOutput {
	s.SlotTypeName = &v
	return s
}

// SetSlotTypeValues sets the SlotTypeValues field's value.
func (s *DescribeSlotTypeOutput) SetSlotTypeValues(v []*SlotTypeValue) *DescribeSlotTypeOutput {
	s.SlotTypeValues = v
	return s
}

// SetValueSelectionSetting sets the ValueSelectionSetting field's value.
func (s *DescribeSlotTypeOutput) SetValueSelectionSetting(v *SlotValueSelectionSetting) *DescribeSlotTypeOutput {
	s.ValueSelectionSetting = v
	return s
}

// Settings that determine the Lambda function that Amazon Lex uses for processing
// user responses.
type DialogCodeHookSettings struct {
	_ struct{} `type:"structure"`

	// Enables the dialog code hook so that it processes user requests.
	//
	// Enabled is a required field
	Enabled *bool `locationName:"enabled" type:"boolean" required:"true"`
}

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

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

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

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

// SetEnabled sets the Enabled field's value.
func (s *DialogCodeHookSettings) SetEnabled(v bool) *DialogCodeHookSettings {
	s.Enabled = &v
	return s
}

// Filtes the response form the operation
type ExportFilter struct {
	_ struct{} `type:"structure"`

	// The name of the field to use for filtering.
	//
	// Name is a required field
	Name *string `locationName:"name" type:"string" required:"true" enum:"ExportFilterName"`

	// The operator to use for the filter. Specify EQ when the ListExports operation
	// should return only resource types that equal the specified value. Specify
	// CO when the ListExports operation should return resource types that contain
	// the specified value.
	//
	// Operator is a required field
	Operator *string `locationName:"operator" type:"string" required:"true" enum:"ExportFilterOperator"`

	// The values to use to fileter the response.
	//
	// Values is a required field
	Values []*string `locationName:"values" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetName sets the Name field's value.
func (s *ExportFilter) SetName(v string) *ExportFilter {
	s.Name = &v
	return s
}

// SetOperator sets the Operator field's value.
func (s *ExportFilter) SetOperator(v string) *ExportFilter {
	s.Operator = &v
	return s
}

// SetValues sets the Values field's value.
func (s *ExportFilter) SetValues(v []*string) *ExportFilter {
	s.Values = v
	return s
}

// Provides information about the bot or bot locale that you want to export.
// You can specify the botExportSpecification or the botLocaleExportSpecification,
// but not both.
type ExportResourceSpecification struct {
	_ struct{} `type:"structure"`

	// Parameters for exporting a bot.
	BotExportSpecification *BotExportSpecification `locationName:"botExportSpecification" type:"structure"`

	// Parameters for exporting a bot locale.
	BotLocaleExportSpecification *BotLocaleExportSpecification `locationName:"botLocaleExportSpecification" type:"structure"`
}

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

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

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

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

// SetBotExportSpecification sets the BotExportSpecification field's value.
func (s *ExportResourceSpecification) SetBotExportSpecification(v *BotExportSpecification) *ExportResourceSpecification {
	s.BotExportSpecification = v
	return s
}

// SetBotLocaleExportSpecification sets the BotLocaleExportSpecification field's value.
func (s *ExportResourceSpecification) SetBotLocaleExportSpecification(v *BotLocaleExportSpecification) *ExportResourceSpecification {
	s.BotLocaleExportSpecification = v
	return s
}

// Provides information about sorting a list of exports.
type ExportSortBy struct {
	_ struct{} `type:"structure"`

	// The export field to use for sorting.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"ExportSortAttribute"`

	// The order to sort the list.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *ExportSortBy) SetAttribute(v string) *ExportSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *ExportSortBy) SetOrder(v string) *ExportSortBy {
	s.Order = &v
	return s
}

// Provides summary information about an export in an export list.
type ExportSummary struct {
	_ struct{} `type:"structure"`

	// The date and time that the export was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The unique identifier that Amazon Lex assigned to the export.
	ExportId *string `locationName:"exportId" min:"10" type:"string"`

	// The status of the export. When the status is Completed the export is ready
	// to download.
	ExportStatus *string `locationName:"exportStatus" type:"string" enum:"ExportStatus"`

	// The file format used in the export files.
	FileFormat *string `locationName:"fileFormat" type:"string" enum:"ImportExportFileFormat"`

	// The date and time that the export was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// Information about the bot or bot locale that was exported.
	ResourceSpecification *ExportResourceSpecification `locationName:"resourceSpecification" type:"structure"`
}

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

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

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *ExportSummary) SetCreationDateTime(v time.Time) *ExportSummary {
	s.CreationDateTime = &v
	return s
}

// SetExportId sets the ExportId field's value.
func (s *ExportSummary) SetExportId(v string) *ExportSummary {
	s.ExportId = &v
	return s
}

// SetExportStatus sets the ExportStatus field's value.
func (s *ExportSummary) SetExportStatus(v string) *ExportSummary {
	s.ExportStatus = &v
	return s
}

// SetFileFormat sets the FileFormat field's value.
func (s *ExportSummary) SetFileFormat(v string) *ExportSummary {
	s.FileFormat = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *ExportSummary) SetLastUpdatedDateTime(v time.Time) *ExportSummary {
	s.LastUpdatedDateTime = &v
	return s
}

// SetResourceSpecification sets the ResourceSpecification field's value.
func (s *ExportSummary) SetResourceSpecification(v *ExportResourceSpecification) *ExportSummary {
	s.ResourceSpecification = v
	return s
}

// Determines if a Lambda function should be invoked for a specific intent.
type FulfillmentCodeHookSettings struct {
	_ struct{} `type:"structure"`

	// Indicates whether a Lambda function should be invoked to fulfill a specific
	// intent.
	//
	// Enabled is a required field
	Enabled *bool `locationName:"enabled" type:"boolean" required:"true"`
}

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

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

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

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

// SetEnabled sets the Enabled field's value.
func (s *FulfillmentCodeHookSettings) SetEnabled(v bool) *FulfillmentCodeHookSettings {
	s.Enabled = &v
	return s
}

// A card that is shown to the user by a messaging platform. You define the
// contents of the card, the card is displayed by the platform.
//
// When you use a response card, the response from the user is constrained to
// the text associated with a button on the card.
type ImageResponseCard struct {
	_ struct{} `type:"structure"`

	// A list of buttons that should be displayed on the response card. The arrangement
	// of the buttons is determined by the platform that displays the button.
	Buttons []*Button `locationName:"buttons" type:"list"`

	// The URL of an image to display on the response card. The image URL must be
	// publicly available so that the platform displaying the response card has
	// access to the image.
	ImageUrl *string `locationName:"imageUrl" min:"1" type:"string"`

	// The subtitle to display on the response card. The format of the subtitle
	// is determined by the platform displaying the response card.
	Subtitle *string `locationName:"subtitle" min:"1" type:"string"`

	// The title to display on the response card. The format of the title is determined
	// by the platform displaying the response card.
	//
	// Title is a required field
	Title *string `locationName:"title" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetButtons sets the Buttons field's value.
func (s *ImageResponseCard) SetButtons(v []*Button) *ImageResponseCard {
	s.Buttons = v
	return s
}

// SetImageUrl sets the ImageUrl field's value.
func (s *ImageResponseCard) SetImageUrl(v string) *ImageResponseCard {
	s.ImageUrl = &v
	return s
}

// SetSubtitle sets the Subtitle field's value.
func (s *ImageResponseCard) SetSubtitle(v string) *ImageResponseCard {
	s.Subtitle = &v
	return s
}

// SetTitle sets the Title field's value.
func (s *ImageResponseCard) SetTitle(v string) *ImageResponseCard {
	s.Title = &v
	return s
}

// Filters the response from the operation.
type ImportFilter struct {
	_ struct{} `type:"structure"`

	// The name of the field to use for filtering.
	//
	// Name is a required field
	Name *string `locationName:"name" type:"string" required:"true" enum:"ImportFilterName"`

	// The operator to use for the filter. Specify EQ when the ListImports operation
	// should return only resource types that equal the specified value. Specify
	// CO when the ListImports operation should return resource types that contain
	// the specified value.
	//
	// Operator is a required field
	Operator *string `locationName:"operator" type:"string" required:"true" enum:"ImportFilterOperator"`

	// The values to use to filter the response.
	//
	// Values is a required field
	Values []*string `locationName:"values" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetName sets the Name field's value.
func (s *ImportFilter) SetName(v string) *ImportFilter {
	s.Name = &v
	return s
}

// SetOperator sets the Operator field's value.
func (s *ImportFilter) SetOperator(v string) *ImportFilter {
	s.Operator = &v
	return s
}

// SetValues sets the Values field's value.
func (s *ImportFilter) SetValues(v []*string) *ImportFilter {
	s.Values = v
	return s
}

// Provides information about the bot or bot locale that you want to import.
// You can sepcifiy the botImportSpecification or the botLocaleImportSpecification,
// but not both.
type ImportResourceSpecification struct {
	_ struct{} `type:"structure"`

	// Parameters for importing a bot.
	BotImportSpecification *BotImportSpecification `locationName:"botImportSpecification" type:"structure"`

	// Parameters for importing a bot locale.
	BotLocaleImportSpecification *BotLocaleImportSpecification `locationName:"botLocaleImportSpecification" type:"structure"`
}

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

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

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

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

// SetBotImportSpecification sets the BotImportSpecification field's value.
func (s *ImportResourceSpecification) SetBotImportSpecification(v *BotImportSpecification) *ImportResourceSpecification {
	s.BotImportSpecification = v
	return s
}

// SetBotLocaleImportSpecification sets the BotLocaleImportSpecification field's value.
func (s *ImportResourceSpecification) SetBotLocaleImportSpecification(v *BotLocaleImportSpecification) *ImportResourceSpecification {
	s.BotLocaleImportSpecification = v
	return s
}

// Provides information for sorting a list of imports.
type ImportSortBy struct {
	_ struct{} `type:"structure"`

	// The export field to use for sorting.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"ImportSortAttribute"`

	// The order to sort the list.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *ImportSortBy) SetAttribute(v string) *ImportSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *ImportSortBy) SetOrder(v string) *ImportSortBy {
	s.Order = &v
	return s
}

// Provides summary information about an import in an import list.
type ImportSummary struct {
	_ struct{} `type:"structure"`

	// The date and time that the import was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The unique identifier that Amazon Lex assigned to the import.
	ImportId *string `locationName:"importId" min:"10" type:"string"`

	// The status of the resource. When the status is Completed the resource is
	// ready to build.
	ImportStatus *string `locationName:"importStatus" type:"string" enum:"ImportStatus"`

	// The unique identifier that Amazon Lex assigned to the imported resource.
	ImportedResourceId *string `locationName:"importedResourceId" min:"5" type:"string"`

	// The name that you gave the imported resource.
	ImportedResourceName *string `locationName:"importedResourceName" min:"1" type:"string"`

	// The date and time that the import was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The strategy used to merge existing bot or bot locale definitions with the
	// imported definition.
	MergeStrategy *string `locationName:"mergeStrategy" type:"string" enum:"MergeStrategy"`
}

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

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

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *ImportSummary) SetCreationDateTime(v time.Time) *ImportSummary {
	s.CreationDateTime = &v
	return s
}

// SetImportId sets the ImportId field's value.
func (s *ImportSummary) SetImportId(v string) *ImportSummary {
	s.ImportId = &v
	return s
}

// SetImportStatus sets the ImportStatus field's value.
func (s *ImportSummary) SetImportStatus(v string) *ImportSummary {
	s.ImportStatus = &v
	return s
}

// SetImportedResourceId sets the ImportedResourceId field's value.
func (s *ImportSummary) SetImportedResourceId(v string) *ImportSummary {
	s.ImportedResourceId = &v
	return s
}

// SetImportedResourceName sets the ImportedResourceName field's value.
func (s *ImportSummary) SetImportedResourceName(v string) *ImportSummary {
	s.ImportedResourceName = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *ImportSummary) SetLastUpdatedDateTime(v time.Time) *ImportSummary {
	s.LastUpdatedDateTime = &v
	return s
}

// SetMergeStrategy sets the MergeStrategy field's value.
func (s *ImportSummary) SetMergeStrategy(v string) *ImportSummary {
	s.MergeStrategy = &v
	return s
}

// The name of a context that must be active for an intent to be selected by
// Amazon Lex.
type InputContext struct {
	_ struct{} `type:"structure"`

	// The name of the context.
	//
	// Name is a required field
	Name *string `locationName:"name" min:"1" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *InputContext) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "InputContext"}
	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
}

// SetName sets the Name field's value.
func (s *InputContext) SetName(v string) *InputContext {
	s.Name = &v
	return s
}

// Provides a statement the Amazon Lex conveys to the user when the intent is
// successfully fulfilled.
type IntentClosingSetting struct {
	_ struct{} `type:"structure"`

	// The response that Amazon Lex sends to the user when the intent is complete.
	//
	// ClosingResponse is a required field
	ClosingResponse *ResponseSpecification `locationName:"closingResponse" type:"structure" required:"true"`
}

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

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

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

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

// SetClosingResponse sets the ClosingResponse field's value.
func (s *IntentClosingSetting) SetClosingResponse(v *ResponseSpecification) *IntentClosingSetting {
	s.ClosingResponse = v
	return s
}

// Provides a prompt for making sure that the user is ready for the intent to
// be fulfilled.
type IntentConfirmationSetting struct {
	_ struct{} `type:"structure"`

	// When the user answers "no" to the question defined in promptSpecification,
	// Amazon Lex responds with this response to acknowledge that the intent was
	// canceled.
	//
	// DeclinationResponse is a required field
	DeclinationResponse *ResponseSpecification `locationName:"declinationResponse" type:"structure" required:"true"`

	// Prompts the user to confirm the intent. This question should have a yes or
	// no answer.
	//
	// Amazon Lex uses this prompt to ensure that the user acknowledges that the
	// intent is ready for fulfillment. For example, with the OrderPizza intent,
	// you might want to confirm that the order is correct before placing it. For
	// other intents, such as intents that simply respond to user questions, you
	// might not need to ask the user for confirmation before providing the information.
	//
	// PromptSpecification is a required field
	PromptSpecification *PromptSpecification `locationName:"promptSpecification" type:"structure" required:"true"`
}

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

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

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

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

// SetDeclinationResponse sets the DeclinationResponse field's value.
func (s *IntentConfirmationSetting) SetDeclinationResponse(v *ResponseSpecification) *IntentConfirmationSetting {
	s.DeclinationResponse = v
	return s
}

// SetPromptSpecification sets the PromptSpecification field's value.
func (s *IntentConfirmationSetting) SetPromptSpecification(v *PromptSpecification) *IntentConfirmationSetting {
	s.PromptSpecification = v
	return s
}

// Filters the response from the ListIntents operation.
type IntentFilter struct {
	_ struct{} `type:"structure"`

	// The name of the field to use for the filter.
	//
	// Name is a required field
	Name *string `locationName:"name" type:"string" required:"true" enum:"IntentFilterName"`

	// The operator to use for the filter. Specify EQ when the ListIntents operation
	// should return only aliases that equal the specified value. Specify CO when
	// the ListIntents operation should return aliases that contain the specified
	// value.
	//
	// Operator is a required field
	Operator *string `locationName:"operator" type:"string" required:"true" enum:"IntentFilterOperator"`

	// The value to use for the filter.
	//
	// Values is a required field
	Values []*string `locationName:"values" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetName sets the Name field's value.
func (s *IntentFilter) SetName(v string) *IntentFilter {
	s.Name = &v
	return s
}

// SetOperator sets the Operator field's value.
func (s *IntentFilter) SetOperator(v string) *IntentFilter {
	s.Operator = &v
	return s
}

// SetValues sets the Values field's value.
func (s *IntentFilter) SetValues(v []*string) *IntentFilter {
	s.Values = v
	return s
}

// Specifies attributes for sorting a list of intents.
type IntentSortBy struct {
	_ struct{} `type:"structure"`

	// The attribute to use to sort the list of intents.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"IntentSortAttribute"`

	// The order to sort the list. You can choose ascending or descending.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *IntentSortBy) SetAttribute(v string) *IntentSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *IntentSortBy) SetOrder(v string) *IntentSortBy {
	s.Order = &v
	return s
}

// Summary information about an intent returned by the ListIntents operation.
type IntentSummary struct {
	_ struct{} `type:"structure"`

	// The description of the intent.
	Description *string `locationName:"description" type:"string"`

	// The input contexts that must be active for this intent to be considered for
	// recognition.
	InputContexts []*InputContext `locationName:"inputContexts" type:"list"`

	// The unique identifier assigned to the intent. Use this ID to get detailed
	// information about the intent with the DescribeIntent operation.
	IntentId *string `locationName:"intentId" min:"10" type:"string"`

	// The name of the intent.
	IntentName *string `locationName:"intentName" min:"1" type:"string"`

	// The timestamp of the date and time that the intent was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The output contexts that are activated when this intent is fulfilled.
	OutputContexts []*OutputContext `locationName:"outputContexts" type:"list"`

	// If this intent is derived from a built-in intent, the name of the parent
	// intent.
	ParentIntentSignature *string `locationName:"parentIntentSignature" type:"string"`
}

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

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

// SetDescription sets the Description field's value.
func (s *IntentSummary) SetDescription(v string) *IntentSummary {
	s.Description = &v
	return s
}

// SetInputContexts sets the InputContexts field's value.
func (s *IntentSummary) SetInputContexts(v []*InputContext) *IntentSummary {
	s.InputContexts = v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *IntentSummary) SetIntentId(v string) *IntentSummary {
	s.IntentId = &v
	return s
}

// SetIntentName sets the IntentName field's value.
func (s *IntentSummary) SetIntentName(v string) *IntentSummary {
	s.IntentName = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *IntentSummary) SetLastUpdatedDateTime(v time.Time) *IntentSummary {
	s.LastUpdatedDateTime = &v
	return s
}

// SetOutputContexts sets the OutputContexts field's value.
func (s *IntentSummary) SetOutputContexts(v []*OutputContext) *IntentSummary {
	s.OutputContexts = v
	return s
}

// SetParentIntentSignature sets the ParentIntentSignature field's value.
func (s *IntentSummary) SetParentIntentSignature(v string) *IntentSummary {
	s.ParentIntentSignature = &v
	return s
}

type InternalServerException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

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

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

func newErrorInternalServerException(v protocol.ResponseMetadata) error {
	return &InternalServerException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *InternalServerException) Code() string {
	return "InternalServerException"
}

// Message returns the exception's message.
func (s *InternalServerException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InternalServerException) OrigErr() error {
	return nil
}

func (s *InternalServerException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *InternalServerException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *InternalServerException) RequestID() string {
	return s.RespMetadata.RequestID
}

// Provides configuration information for the AMAZON.KendraSearchIntent intent.
// When you use this intent, Amazon Lex searches the specified Amazon Kendra
// index and returns documents from the index that match the user's utterance.
type KendraConfiguration struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the Amazon Kendra index that you want the
	// AMAZON.KendraSearchIntent intent to search. The index must be in the same
	// account and Region as the Amazon Lex bot.
	//
	// KendraIndex is a required field
	KendraIndex *string `locationName:"kendraIndex" min:"32" type:"string" required:"true"`

	// A query filter that Amazon Lex sends to Amazon Kendra to filter the response
	// from a query. The filter is in the format defined by Amazon Kendra. For more
	// information, see Filtering queries (https://docs.aws.amazon.com/kendra/latest/dg/filtering.html).
	QueryFilterString *string `locationName:"queryFilterString" min:"1" type:"string"`

	// Determines whether the AMAZON.KendraSearchIntent intent uses a custom query
	// string to query the Amazon Kendra index.
	QueryFilterStringEnabled *bool `locationName:"queryFilterStringEnabled" type:"boolean"`
}

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

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

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

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

// SetKendraIndex sets the KendraIndex field's value.
func (s *KendraConfiguration) SetKendraIndex(v string) *KendraConfiguration {
	s.KendraIndex = &v
	return s
}

// SetQueryFilterString sets the QueryFilterString field's value.
func (s *KendraConfiguration) SetQueryFilterString(v string) *KendraConfiguration {
	s.QueryFilterString = &v
	return s
}

// SetQueryFilterStringEnabled sets the QueryFilterStringEnabled field's value.
func (s *KendraConfiguration) SetQueryFilterStringEnabled(v bool) *KendraConfiguration {
	s.QueryFilterStringEnabled = &v
	return s
}

// Specifies a Lambda function that verifies requests to a bot or fulfilles
// the user's request to a bot.
type LambdaCodeHook struct {
	_ struct{} `type:"structure"`

	// The version of the request-response that you want Amazon Lex to use to invoke
	// your Lambda function.
	//
	// CodeHookInterfaceVersion is a required field
	CodeHookInterfaceVersion *string `locationName:"codeHookInterfaceVersion" min:"1" type:"string" required:"true"`

	// The Amazon Resource Name (ARN) of the Lambda function.
	//
	// LambdaARN is a required field
	LambdaARN *string `locationName:"lambdaARN" min:"20" type:"string" required:"true"`
}

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

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

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

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

// SetCodeHookInterfaceVersion sets the CodeHookInterfaceVersion field's value.
func (s *LambdaCodeHook) SetCodeHookInterfaceVersion(v string) *LambdaCodeHook {
	s.CodeHookInterfaceVersion = &v
	return s
}

// SetLambdaARN sets the LambdaARN field's value.
func (s *LambdaCodeHook) SetLambdaARN(v string) *LambdaCodeHook {
	s.LambdaARN = &v
	return s
}

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

	// The identifier of the bot to list aliases for.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The maximum number of aliases to return in each page of results. If there
	// are fewer results than the max page size, only the actual number of results
	// are returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response from the ListBotAliases operation contains more results than
	// specified in the maxResults parameter, a token is returned in the response.
	// Use that token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *ListBotAliasesInput) SetBotId(v string) *ListBotAliasesInput {
	s.BotId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListBotAliasesInput) SetMaxResults(v int64) *ListBotAliasesInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBotAliasesInput) SetNextToken(v string) *ListBotAliasesInput {
	s.NextToken = &v
	return s
}

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

	// Summary information for the bot aliases that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter
	// of the request. If there are more aliases available, the nextToken field
	// contains a token to get the next page of results.
	BotAliasSummaries []*BotAliasSummary `locationName:"botAliasSummaries" type:"list"`

	// The identifier of the bot associated with the aliases.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// A token that indicates whether there are more results to return in a response
	// to the ListBotAliases operation. If the nextToken field is present, you send
	// the contents as the nextToken parameter of a ListBotAliases operation request
	// to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBotAliasSummaries sets the BotAliasSummaries field's value.
func (s *ListBotAliasesOutput) SetBotAliasSummaries(v []*BotAliasSummary) *ListBotAliasesOutput {
	s.BotAliasSummaries = v
	return s
}

// SetBotId sets the BotId field's value.
func (s *ListBotAliasesOutput) SetBotId(v string) *ListBotAliasesOutput {
	s.BotId = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBotAliasesOutput) SetNextToken(v string) *ListBotAliasesOutput {
	s.NextToken = &v
	return s
}

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

	// The identifier of the bot to list locales for.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot to list locales for.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// Provides the specification for a filter used to limit the response to only
	// those locales that match the filter specification. You can only specify one
	// filter and one value to filter on.
	Filters []*BotLocaleFilter `locationName:"filters" min:"1" type:"list"`

	// The maximum number of aliases to return in each page of results. If there
	// are fewer results than the max page size, only the actual number of results
	// are returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response from the ListBotLocales operation contains more results than
	// specified in the maxResults parameter, a token is returned in the response.
	// Use that token as the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Specifies sorting parameters for the list of locales. You can sort by locale
	// name in ascending or descending order.
	SortBy *BotLocaleSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *ListBotLocalesInput) SetBotId(v string) *ListBotLocalesInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListBotLocalesInput) SetBotVersion(v string) *ListBotLocalesInput {
	s.BotVersion = &v
	return s
}

// SetFilters sets the Filters field's value.
func (s *ListBotLocalesInput) SetFilters(v []*BotLocaleFilter) *ListBotLocalesInput {
	s.Filters = v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListBotLocalesInput) SetMaxResults(v int64) *ListBotLocalesInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBotLocalesInput) SetNextToken(v string) *ListBotLocalesInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListBotLocalesInput) SetSortBy(v *BotLocaleSortBy) *ListBotLocalesInput {
	s.SortBy = v
	return s
}

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

	// The identifier of the bot to list locales for.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// Summary information for the locales that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter
	// of the request. If there are more locales available, the nextToken field
	// contains a token to get the next page of results.
	BotLocaleSummaries []*BotLocaleSummary `locationName:"botLocaleSummaries" type:"list"`

	// The version of the bot.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// A token that indicates whether there are more results to return in a response
	// to the ListBotLocales operation. If the nextToken field is present, you send
	// the contents as the nextToken parameter of a ListBotLocales operation request
	// to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *ListBotLocalesOutput) SetBotId(v string) *ListBotLocalesOutput {
	s.BotId = &v
	return s
}

// SetBotLocaleSummaries sets the BotLocaleSummaries field's value.
func (s *ListBotLocalesOutput) SetBotLocaleSummaries(v []*BotLocaleSummary) *ListBotLocalesOutput {
	s.BotLocaleSummaries = v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListBotLocalesOutput) SetBotVersion(v string) *ListBotLocalesOutput {
	s.BotVersion = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBotLocalesOutput) SetNextToken(v string) *ListBotLocalesOutput {
	s.NextToken = &v
	return s
}

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

	// The identifier of the bot to list versions for.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The maximum number of versions to return in each page of results. If there
	// are fewer results than the max page size, only the actual number of results
	// are returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response to the ListBotVersion operation contains more results than
	// specified in the maxResults parameter, a token is returned in the response.
	// Use that token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Specifies sorting parameters for the list of versions. You can specify that
	// the list be sorted by version name in either ascending or descending order.
	SortBy *BotVersionSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *ListBotVersionsInput) SetBotId(v string) *ListBotVersionsInput {
	s.BotId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListBotVersionsInput) SetMaxResults(v int64) *ListBotVersionsInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBotVersionsInput) SetNextToken(v string) *ListBotVersionsInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListBotVersionsInput) SetSortBy(v *BotVersionSortBy) *ListBotVersionsInput {
	s.SortBy = v
	return s
}

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

	// The identifier of the bot to list versions for.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// Summary information for the bot versions that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter
	// of the request. If there are more versions available, the nextToken field
	// contains a token to get the next page of results.
	BotVersionSummaries []*BotVersionSummary `locationName:"botVersionSummaries" type:"list"`

	// A token that indicates whether there are more results to return in a response
	// to the ListBotVersions operation. If the nextToken field is present, you
	// send the contents as the nextToken parameter of a ListBotAliases operation
	// request to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *ListBotVersionsOutput) SetBotId(v string) *ListBotVersionsOutput {
	s.BotId = &v
	return s
}

// SetBotVersionSummaries sets the BotVersionSummaries field's value.
func (s *ListBotVersionsOutput) SetBotVersionSummaries(v []*BotVersionSummary) *ListBotVersionsOutput {
	s.BotVersionSummaries = v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBotVersionsOutput) SetNextToken(v string) *ListBotVersionsOutput {
	s.NextToken = &v
	return s
}

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

	// Provides the specification of a filter used to limit the bots in the response
	// to only those that match the filter specification. You can only specify one
	// filter and one string to filter on.
	Filters []*BotFilter `locationName:"filters" min:"1" type:"list"`

	// The maximum number of bots to return in each page of results. If there are
	// fewer results than the maximum page size, only the actual number of results
	// are returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response from the ListBots operation contains more results than specified
	// in the maxResults parameter, a token is returned in the response. Use that
	// token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Specifies sorting parameters for the list of bots. You can specify that the
	// list be sorted by bot name in ascending or descending order.
	SortBy *BotSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetFilters sets the Filters field's value.
func (s *ListBotsInput) SetFilters(v []*BotFilter) *ListBotsInput {
	s.Filters = v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListBotsInput) SetMaxResults(v int64) *ListBotsInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBotsInput) SetNextToken(v string) *ListBotsInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListBotsInput) SetSortBy(v *BotSortBy) *ListBotsInput {
	s.SortBy = v
	return s
}

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

	// Summary information for the bots that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter
	// of the request. If there are more bots available, the nextToken field contains
	// a token to the next page of results.
	BotSummaries []*BotSummary `locationName:"botSummaries" type:"list"`

	// A token that indicates whether there are more results to return in a response
	// to the ListBots operation. If the nextToken field is present, you send the
	// contents as the nextToken parameter of a ListBots operation request to get
	// the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBotSummaries sets the BotSummaries field's value.
func (s *ListBotsOutput) SetBotSummaries(v []*BotSummary) *ListBotsOutput {
	s.BotSummaries = v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBotsOutput) SetNextToken(v string) *ListBotsOutput {
	s.NextToken = &v
	return s
}

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

	// The identifier of the language and locale of the intents to list. The string
	// must match one of the supported locales. For more information, see Supported
	// languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The maximum number of built-in intents to return in each page of results.
	// If there are fewer results than the max page size, only the actual number
	// of results are returned.
	MaxResults *int64 `locationName:"maxResults" min:"20" type:"integer"`

	// If the response from the ListBuiltInIntents operation contains more results
	// than specified in the maxResults parameter, a token is returned in the response.
	// Use that token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Specifies sorting parameters for the list of built-in intents. You can specify
	// that the list be sorted by the built-in intent signature in either ascending
	// or descending order.
	SortBy *BuiltInIntentSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetLocaleId sets the LocaleId field's value.
func (s *ListBuiltInIntentsInput) SetLocaleId(v string) *ListBuiltInIntentsInput {
	s.LocaleId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListBuiltInIntentsInput) SetMaxResults(v int64) *ListBuiltInIntentsInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBuiltInIntentsInput) SetNextToken(v string) *ListBuiltInIntentsInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListBuiltInIntentsInput) SetSortBy(v *BuiltInIntentSortBy) *ListBuiltInIntentsInput {
	s.SortBy = v
	return s
}

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

	// Summary information for the built-in intents that meet the filter criteria
	// specified in the request. The length of the list is specified in the maxResults
	// parameter of the request. If there are more intents available, the nextToken
	// field contains a token to get the next page of results.
	BuiltInIntentSummaries []*BuiltInIntentSummary `locationName:"builtInIntentSummaries" type:"list"`

	// The language and locale of the intents in the list.
	LocaleId *string `locationName:"localeId" type:"string"`

	// A token that indicates whether there are more results to return in a response
	// to the ListBuiltInIntents operation. If the nextToken field is present, you
	// send the contents as the nextToken parameter of a ListBotAliases operation
	// request to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBuiltInIntentSummaries sets the BuiltInIntentSummaries field's value.
func (s *ListBuiltInIntentsOutput) SetBuiltInIntentSummaries(v []*BuiltInIntentSummary) *ListBuiltInIntentsOutput {
	s.BuiltInIntentSummaries = v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *ListBuiltInIntentsOutput) SetLocaleId(v string) *ListBuiltInIntentsOutput {
	s.LocaleId = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBuiltInIntentsOutput) SetNextToken(v string) *ListBuiltInIntentsOutput {
	s.NextToken = &v
	return s
}

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

	// The identifier of the language and locale of the slot types to list. The
	// string must match one of the supported locales. For more information, see
	// Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The maximum number of built-in slot types to return in each page of results.
	// If there are fewer results than the max page size, only the actual number
	// of results are returned.
	MaxResults *int64 `locationName:"maxResults" min:"20" type:"integer"`

	// If the response from the ListBuiltInSlotTypes operation contains more results
	// than specified in the maxResults parameter, a token is returned in the response.
	// Use that token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Determines the sort order for the response from the ListBuiltInSlotTypes
	// operation. You can choose to sort by the slot type signature in either ascending
	// or descending order.
	SortBy *BuiltInSlotTypeSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetLocaleId sets the LocaleId field's value.
func (s *ListBuiltInSlotTypesInput) SetLocaleId(v string) *ListBuiltInSlotTypesInput {
	s.LocaleId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListBuiltInSlotTypesInput) SetMaxResults(v int64) *ListBuiltInSlotTypesInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBuiltInSlotTypesInput) SetNextToken(v string) *ListBuiltInSlotTypesInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListBuiltInSlotTypesInput) SetSortBy(v *BuiltInSlotTypeSortBy) *ListBuiltInSlotTypesInput {
	s.SortBy = v
	return s
}

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

	// Summary information for the built-in slot types that meet the filter criteria
	// specified in the request. The length of the list is specified in the maxResults
	// parameter of the request. If there are more slot types available, the nextToken
	// field contains a token to get the next page of results.
	BuiltInSlotTypeSummaries []*BuiltInSlotTypeSummary `locationName:"builtInSlotTypeSummaries" type:"list"`

	// The language and locale of the slot types in the list.
	LocaleId *string `locationName:"localeId" type:"string"`

	// A token that indicates whether there are more results to return in a response
	// to the ListBuiltInSlotTypes operation. If the nextToken field is present,
	// you send the contents as the nextToken parameter of a LIstBuiltInSlotTypes
	// operation request to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBuiltInSlotTypeSummaries sets the BuiltInSlotTypeSummaries field's value.
func (s *ListBuiltInSlotTypesOutput) SetBuiltInSlotTypeSummaries(v []*BuiltInSlotTypeSummary) *ListBuiltInSlotTypesOutput {
	s.BuiltInSlotTypeSummaries = v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *ListBuiltInSlotTypesOutput) SetLocaleId(v string) *ListBuiltInSlotTypesOutput {
	s.LocaleId = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListBuiltInSlotTypesOutput) SetNextToken(v string) *ListBuiltInSlotTypesOutput {
	s.NextToken = &v
	return s
}

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

	// The unique identifier that Amazon Lex assigned to the bot.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot to list exports for.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// Provides the specification of a filter used to limit the exports in the response
	// to only those that match the filter specification. You can only specify one
	// filter and one string to filter on.
	Filters []*ExportFilter `locationName:"filters" min:"1" type:"list"`

	// The maximum number of exports to return in each page of results. If there
	// are fewer results than the max page size, only the actual number of results
	// are returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response from the ListExports operation contans more results that
	// specified in the maxResults parameter, a token is returned in the response.
	// Use that token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Determines the field that the list of exports is sorted by. You can sort
	// by the LastUpdatedDateTime field in ascending or descending order.
	SortBy *ExportSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *ListExportsInput) SetBotId(v string) *ListExportsInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListExportsInput) SetBotVersion(v string) *ListExportsInput {
	s.BotVersion = &v
	return s
}

// SetFilters sets the Filters field's value.
func (s *ListExportsInput) SetFilters(v []*ExportFilter) *ListExportsInput {
	s.Filters = v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListExportsInput) SetMaxResults(v int64) *ListExportsInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListExportsInput) SetNextToken(v string) *ListExportsInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListExportsInput) SetSortBy(v *ExportSortBy) *ListExportsInput {
	s.SortBy = v
	return s
}

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

	// The unique identifier assigned to the bot by Amazon Lex.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot that was exported.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// Summary information for the exports that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter.
	// If there are more exports available, the nextToken field contains a token
	// to get the next page of results.
	ExportSummaries []*ExportSummary `locationName:"exportSummaries" type:"list"`

	// A token that indicates whether there are more results to return in a response
	// to the ListExports operation. If the nextToken field is present, you send
	// the contents as the nextToken parameter of a ListExports operation request
	// to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *ListExportsOutput) SetBotId(v string) *ListExportsOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListExportsOutput) SetBotVersion(v string) *ListExportsOutput {
	s.BotVersion = &v
	return s
}

// SetExportSummaries sets the ExportSummaries field's value.
func (s *ListExportsOutput) SetExportSummaries(v []*ExportSummary) *ListExportsOutput {
	s.ExportSummaries = v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListExportsOutput) SetNextToken(v string) *ListExportsOutput {
	s.NextToken = &v
	return s
}

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

	// The unique identifier that Amazon Lex assigned to the bot.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot to list imports for.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// Provides the specification of a filter used to limit the bots in the response
	// to only those that match the filter specification. You can only specify one
	// filter and one string to filter on.
	Filters []*ImportFilter `locationName:"filters" min:"1" type:"list"`

	// The maximum number of imports to return in each page of results. If there
	// are fewer results than the max page size, only the actual number of results
	// are returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response from the ListImports operation contains more results than
	// specified in the maxResults parameter, a token is returned in the response.
	// Use that token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Determines the field that the list of imports is sorted by. You can sort
	// by the LastUpdatedDateTime field in ascending or descending order.
	SortBy *ImportSortBy `locationName:"sortBy" type:"structure"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListImportsInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "ListImportsInput"}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.Filters != nil && len(s.Filters) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Filters", 1))
	}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
	}
	if s.Filters != nil {
		for i, v := range s.Filters {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(request.ErrInvalidParams))
			}
		}
	}
	if s.SortBy != nil {
		if err := s.SortBy.Validate(); err != nil {
			invalidParams.AddNested("SortBy", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *ListImportsInput) SetBotId(v string) *ListImportsInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListImportsInput) SetBotVersion(v string) *ListImportsInput {
	s.BotVersion = &v
	return s
}

// SetFilters sets the Filters field's value.
func (s *ListImportsInput) SetFilters(v []*ImportFilter) *ListImportsInput {
	s.Filters = v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListImportsInput) SetMaxResults(v int64) *ListImportsInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListImportsInput) SetNextToken(v string) *ListImportsInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListImportsInput) SetSortBy(v *ImportSortBy) *ListImportsInput {
	s.SortBy = v
	return s
}

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

	// The unique identifier assigned by Amazon Lex to the bot.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot that was imported. It will always be DRAFT.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// Summary information for the imports that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter.
	// If there are more imports available, the nextToken field contains a token
	// to get the next page of results.
	ImportSummaries []*ImportSummary `locationName:"importSummaries" type:"list"`

	// A token that indicates whether there are more results to return in a response
	// to the ListImports operation. If the nextToken field is present, you send
	// the contents as the nextToken parameter of a ListImports operation request
	// to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *ListImportsOutput) SetBotId(v string) *ListImportsOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListImportsOutput) SetBotVersion(v string) *ListImportsOutput {
	s.BotVersion = &v
	return s
}

// SetImportSummaries sets the ImportSummaries field's value.
func (s *ListImportsOutput) SetImportSummaries(v []*ImportSummary) *ListImportsOutput {
	s.ImportSummaries = v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListImportsOutput) SetNextToken(v string) *ListImportsOutput {
	s.NextToken = &v
	return s
}

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

	// The unique identifier of the bot that contains the intent.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that contains the intent.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// Provides the specification of a filter used to limit the intents in the response
	// to only those that match the filter specification. You can only specify one
	// filter and only one string to filter on.
	Filters []*IntentFilter `locationName:"filters" min:"1" type:"list"`

	// The identifier of the language and locale of the intents to list. The string
	// must match one of the supported locales. For more information, see Supported
	// languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The maximum number of intents to return in each page of results. If there
	// are fewer results than the max page size, only the actual number of results
	// are returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response from the ListIntents operation contains more results than
	// specified in the maxResults parameter, a token is returned in the response.
	// Use that token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Determines the sort order for the response from the ListIntents operation.
	// You can choose to sort by the intent name or last updated date in either
	// ascending or descending order.
	SortBy *IntentSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *ListIntentsInput) SetBotId(v string) *ListIntentsInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListIntentsInput) SetBotVersion(v string) *ListIntentsInput {
	s.BotVersion = &v
	return s
}

// SetFilters sets the Filters field's value.
func (s *ListIntentsInput) SetFilters(v []*IntentFilter) *ListIntentsInput {
	s.Filters = v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *ListIntentsInput) SetLocaleId(v string) *ListIntentsInput {
	s.LocaleId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListIntentsInput) SetMaxResults(v int64) *ListIntentsInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListIntentsInput) SetNextToken(v string) *ListIntentsInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListIntentsInput) SetSortBy(v *IntentSortBy) *ListIntentsInput {
	s.SortBy = v
	return s
}

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

	// The identifier of the bot that contains the intent.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot that contains the intent.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// Summary information for the intents that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter
	// of the request. If there are more intents available, the nextToken field
	// contains a token to get the next page of results.
	IntentSummaries []*IntentSummary `locationName:"intentSummaries" type:"list"`

	// The language and locale of the intents in the list.
	LocaleId *string `locationName:"localeId" type:"string"`

	// A token that indicates whether there are more results to return in a response
	// to the ListIntents operation. If the nextToken field is present, you send
	// the contents as the nextToken parameter of a ListIntents operation request
	// to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *ListIntentsOutput) SetBotId(v string) *ListIntentsOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListIntentsOutput) SetBotVersion(v string) *ListIntentsOutput {
	s.BotVersion = &v
	return s
}

// SetIntentSummaries sets the IntentSummaries field's value.
func (s *ListIntentsOutput) SetIntentSummaries(v []*IntentSummary) *ListIntentsOutput {
	s.IntentSummaries = v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *ListIntentsOutput) SetLocaleId(v string) *ListIntentsOutput {
	s.LocaleId = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListIntentsOutput) SetNextToken(v string) *ListIntentsOutput {
	s.NextToken = &v
	return s
}

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

	// The unique identifier of the bot that contains the slot types.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that contains the slot type.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// Provides the specification of a filter used to limit the slot types in the
	// response to only those that match the filter specification. You can only
	// specify one filter and only one string to filter on.
	Filters []*SlotTypeFilter `locationName:"filters" min:"1" type:"list"`

	// The identifier of the language and locale of the slot types to list. The
	// string must match one of the supported locales. For more information, see
	// Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The maximum number of slot types to return in each page of results. If there
	// are fewer results than the max page size, only the actual number of results
	// are returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response from the ListSlotTypes operation contains more results than
	// specified in the maxResults parameter, a token is returned in the response.
	// Use that token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Determines the sort order for the response from the ListSlotTypes operation.
	// You can choose to sort by the slot type name or last updated date in either
	// ascending or descending order.
	SortBy *SlotTypeSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *ListSlotTypesInput) SetBotId(v string) *ListSlotTypesInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListSlotTypesInput) SetBotVersion(v string) *ListSlotTypesInput {
	s.BotVersion = &v
	return s
}

// SetFilters sets the Filters field's value.
func (s *ListSlotTypesInput) SetFilters(v []*SlotTypeFilter) *ListSlotTypesInput {
	s.Filters = v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *ListSlotTypesInput) SetLocaleId(v string) *ListSlotTypesInput {
	s.LocaleId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListSlotTypesInput) SetMaxResults(v int64) *ListSlotTypesInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListSlotTypesInput) SetNextToken(v string) *ListSlotTypesInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListSlotTypesInput) SetSortBy(v *SlotTypeSortBy) *ListSlotTypesInput {
	s.SortBy = v
	return s
}

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

	// The identifier of the bot that contains the slot types.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot that contains the slot types.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// The language and local of the slot types in the list.
	LocaleId *string `locationName:"localeId" type:"string"`

	// A token that indicates whether there are more results to return in a response
	// to the ListSlotTypes operation. If the nextToken field is present, you send
	// the contents as the nextToken parameter of a ListSlotTypes operation request
	// to get the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Summary information for the slot types that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter
	// of the request. If there are more slot types available, the nextToken field
	// contains a token to get the next page of results.
	SlotTypeSummaries []*SlotTypeSummary `locationName:"slotTypeSummaries" type:"list"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *ListSlotTypesOutput) SetBotId(v string) *ListSlotTypesOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListSlotTypesOutput) SetBotVersion(v string) *ListSlotTypesOutput {
	s.BotVersion = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *ListSlotTypesOutput) SetLocaleId(v string) *ListSlotTypesOutput {
	s.LocaleId = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListSlotTypesOutput) SetNextToken(v string) *ListSlotTypesOutput {
	s.NextToken = &v
	return s
}

// SetSlotTypeSummaries sets the SlotTypeSummaries field's value.
func (s *ListSlotTypesOutput) SetSlotTypeSummaries(v []*SlotTypeSummary) *ListSlotTypesOutput {
	s.SlotTypeSummaries = v
	return s
}

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

	// The identifier of the bot that contains the slot.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that contains the slot.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"1" type:"string" required:"true"`

	// Provides the specification of a filter used to limit the slots in the response
	// to only those that match the filter specification. You can only specify one
	// filter and only one string to filter on.
	Filters []*SlotFilter `locationName:"filters" min:"1" type:"list"`

	// The unique identifier of the intent that contains the slot.
	//
	// IntentId is a required field
	IntentId *string `location:"uri" locationName:"intentId" min:"10" type:"string" required:"true"`

	// The identifier of the language and locale of the slots to list. The string
	// must match one of the supported locales. For more information, see Supported
	// languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The maximum number of slots to return in each page of results. If there are
	// fewer results than the max page size, only the actual number of results are
	// returned.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// If the response from the ListSlots operation contains more results than specified
	// in the maxResults parameter, a token is returned in the response. Use that
	// token in the nextToken parameter to return the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Determines the sort order for the response from the ListSlots operation.
	// You can choose to sort by the slot name or last updated date in either ascending
	// or descending order.
	SortBy *SlotSortBy `locationName:"sortBy" type:"structure"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *ListSlotsInput) SetBotId(v string) *ListSlotsInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListSlotsInput) SetBotVersion(v string) *ListSlotsInput {
	s.BotVersion = &v
	return s
}

// SetFilters sets the Filters field's value.
func (s *ListSlotsInput) SetFilters(v []*SlotFilter) *ListSlotsInput {
	s.Filters = v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *ListSlotsInput) SetIntentId(v string) *ListSlotsInput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *ListSlotsInput) SetLocaleId(v string) *ListSlotsInput {
	s.LocaleId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *ListSlotsInput) SetMaxResults(v int64) *ListSlotsInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListSlotsInput) SetNextToken(v string) *ListSlotsInput {
	s.NextToken = &v
	return s
}

// SetSortBy sets the SortBy field's value.
func (s *ListSlotsInput) SetSortBy(v *SlotSortBy) *ListSlotsInput {
	s.SortBy = v
	return s
}

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

	// The identifier of the bot that contains the slots.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot that contains the slots.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// The identifier of the intent that contains the slots.
	IntentId *string `locationName:"intentId" min:"10" type:"string"`

	// The language and locale of the slots in the list.
	LocaleId *string `locationName:"localeId" type:"string"`

	// A token that indicates whether there are more results to return in a response
	// to the ListSlots operation. If the nextToken field is present, you send the
	// contents as the nextToken parameter of a ListSlots operation request to get
	// the next page of results.
	NextToken *string `locationName:"nextToken" type:"string"`

	// Summary information for the slots that meet the filter criteria specified
	// in the request. The length of the list is specified in the maxResults parameter
	// of the request. If there are more slots available, the nextToken field contains
	// a token to get the next page of results.
	SlotSummaries []*SlotSummary `locationName:"slotSummaries" type:"list"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *ListSlotsOutput) SetBotId(v string) *ListSlotsOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *ListSlotsOutput) SetBotVersion(v string) *ListSlotsOutput {
	s.BotVersion = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *ListSlotsOutput) SetIntentId(v string) *ListSlotsOutput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *ListSlotsOutput) SetLocaleId(v string) *ListSlotsOutput {
	s.LocaleId = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListSlotsOutput) SetNextToken(v string) *ListSlotsOutput {
	s.NextToken = &v
	return s
}

// SetSlotSummaries sets the SlotSummaries field's value.
func (s *ListSlotsOutput) SetSlotSummaries(v []*SlotSummary) *ListSlotsOutput {
	s.SlotSummaries = v
	return s
}

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

	// The Amazon Resource Name (ARN) of the resource to get a list of tags for.
	//
	// ResourceARN is a required field
	ResourceARN *string `location:"uri" locationName:"resourceARN" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetResourceARN sets the ResourceARN field's value.
func (s *ListTagsForResourceInput) SetResourceARN(v string) *ListTagsForResourceInput {
	s.ResourceARN = &v
	return s
}

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

	// The tags associated with a resource.
	Tags map[string]*string `locationName:"tags" type:"map"`
}

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

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

// SetTags sets the Tags field's value.
func (s *ListTagsForResourceOutput) SetTags(v map[string]*string) *ListTagsForResourceOutput {
	s.Tags = v
	return s
}

// The object that provides message text and it's type.
type Message struct {
	_ struct{} `type:"structure"`

	// A message in a custom format defined by the client application.
	CustomPayload *CustomPayload `locationName:"customPayload" type:"structure"`

	// A message that defines a response card that the client application can show
	// to the user.
	ImageResponseCard *ImageResponseCard `locationName:"imageResponseCard" type:"structure"`

	// A message in plain text format.
	PlainTextMessage *PlainTextMessage `locationName:"plainTextMessage" type:"structure"`

	// A message in Speech Synthesis Markup Language (SSML).
	SsmlMessage *SSMLMessage `locationName:"ssmlMessage" type:"structure"`
}

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

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

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

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

// SetCustomPayload sets the CustomPayload field's value.
func (s *Message) SetCustomPayload(v *CustomPayload) *Message {
	s.CustomPayload = v
	return s
}

// SetImageResponseCard sets the ImageResponseCard field's value.
func (s *Message) SetImageResponseCard(v *ImageResponseCard) *Message {
	s.ImageResponseCard = v
	return s
}

// SetPlainTextMessage sets the PlainTextMessage field's value.
func (s *Message) SetPlainTextMessage(v *PlainTextMessage) *Message {
	s.PlainTextMessage = v
	return s
}

// SetSsmlMessage sets the SsmlMessage field's value.
func (s *Message) SetSsmlMessage(v *SSMLMessage) *Message {
	s.SsmlMessage = v
	return s
}

// Provides one or more messages that Amazon Lex should send to the user.
type MessageGroup struct {
	_ struct{} `type:"structure"`

	// The primary message that Amazon Lex should send to the user.
	//
	// Message is a required field
	Message *Message `locationName:"message" type:"structure" required:"true"`

	// Message variations to send to the user. When variations are defined, Amazon
	// Lex chooses the primary message or one of the variations to send to the user.
	Variations []*Message `locationName:"variations" type:"list"`
}

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

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

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

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

// SetMessage sets the Message field's value.
func (s *MessageGroup) SetMessage(v *Message) *MessageGroup {
	s.Message = v
	return s
}

// SetVariations sets the Variations field's value.
func (s *MessageGroup) SetVariations(v []*Message) *MessageGroup {
	s.Variations = v
	return s
}

// Indicates whether a slot can return multiple values.
type MultipleValuesSetting struct {
	_ struct{} `type:"structure"`

	// Indicates whether a slot can return multiple values. When true, the slot
	// may return more than one value in a response. When false, the slot returns
	// only a single value.
	//
	// Multi-value slots are only available in the en-US locale. If you set this
	// value to true in any other locale, Amazon Lex throws a ValidationException.
	//
	// If the allowMutlipleValues is not set, the default value is false.
	AllowMultipleValues *bool `locationName:"allowMultipleValues" type:"boolean"`
}

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

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

// SetAllowMultipleValues sets the AllowMultipleValues field's value.
func (s *MultipleValuesSetting) SetAllowMultipleValues(v bool) *MultipleValuesSetting {
	s.AllowMultipleValues = &v
	return s
}

// Determines whether Amazon Lex obscures slot values in conversation logs.
type ObfuscationSetting struct {
	_ struct{} `type:"structure"`

	// Value that determines whether Amazon Lex obscures slot values in conversation
	// logs. The default is to obscure the values.
	//
	// ObfuscationSettingType is a required field
	ObfuscationSettingType *string `locationName:"obfuscationSettingType" type:"string" required:"true" enum:"ObfuscationSettingType"`
}

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

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

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

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

// SetObfuscationSettingType sets the ObfuscationSettingType field's value.
func (s *ObfuscationSetting) SetObfuscationSettingType(v string) *ObfuscationSetting {
	s.ObfuscationSettingType = &v
	return s
}

// Describes a session context that is activated when an intent is fulfilled.
type OutputContext struct {
	_ struct{} `type:"structure"`

	// The name of the output context.
	//
	// Name is a required field
	Name *string `locationName:"name" min:"1" type:"string" required:"true"`

	// The amount of time, in seconds, that the output context should remain active.
	// The time is figured from the first time the context is sent to the user.
	//
	// TimeToLiveInSeconds is a required field
	TimeToLiveInSeconds *int64 `locationName:"timeToLiveInSeconds" min:"5" type:"integer" required:"true"`

	// The number of conversation turns that the output context should remain active.
	// The number of turns is counted from the first time that the context is sent
	// to the user.
	//
	// TurnsToLive is a required field
	TurnsToLive *int64 `locationName:"turnsToLive" min:"1" type:"integer" required:"true"`
}

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

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

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

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

// SetName sets the Name field's value.
func (s *OutputContext) SetName(v string) *OutputContext {
	s.Name = &v
	return s
}

// SetTimeToLiveInSeconds sets the TimeToLiveInSeconds field's value.
func (s *OutputContext) SetTimeToLiveInSeconds(v int64) *OutputContext {
	s.TimeToLiveInSeconds = &v
	return s
}

// SetTurnsToLive sets the TurnsToLive field's value.
func (s *OutputContext) SetTurnsToLive(v int64) *OutputContext {
	s.TurnsToLive = &v
	return s
}

// Defines an ASCII text message to send to the user.
type PlainTextMessage struct {
	_ struct{} `type:"structure"`

	// The message to send to the user.
	//
	// Value is a required field
	Value *string `locationName:"value" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetValue sets the Value field's value.
func (s *PlainTextMessage) SetValue(v string) *PlainTextMessage {
	s.Value = &v
	return s
}

type PreconditionFailedException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

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

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

func newErrorPreconditionFailedException(v protocol.ResponseMetadata) error {
	return &PreconditionFailedException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *PreconditionFailedException) Code() string {
	return "PreconditionFailedException"
}

// Message returns the exception's message.
func (s *PreconditionFailedException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *PreconditionFailedException) OrigErr() error {
	return nil
}

func (s *PreconditionFailedException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *PreconditionFailedException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *PreconditionFailedException) RequestID() string {
	return s.RespMetadata.RequestID
}

// The IAM principal that you allowing or denying access to an Amazon Lex action.
// You must provide a service or an arn, but not both in the same statement.
// For more information, see AWS JSON policy elements: Principal (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html).
type Principal struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the principal.
	Arn *string `locationName:"arn" min:"30" type:"string"`

	// The name of the AWS service that should allowed or denied access to an Amazon
	// Lex action.
	Service *string `locationName:"service" min:"15" type:"string"`
}

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

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

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

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

// SetArn sets the Arn field's value.
func (s *Principal) SetArn(v string) *Principal {
	s.Arn = &v
	return s
}

// SetService sets the Service field's value.
func (s *Principal) SetService(v string) *Principal {
	s.Service = &v
	return s
}

// Specifies a list of message groups that Amazon Lex sends to a user to elicit
// a response.
type PromptSpecification struct {
	_ struct{} `type:"structure"`

	// Indicates whether the user can interrupt a speech prompt from the bot.
	AllowInterrupt *bool `locationName:"allowInterrupt" type:"boolean"`

	// The maximum number of times the bot tries to elicit a resonse from the user
	// using this prompt.
	//
	// MaxRetries is a required field
	MaxRetries *int64 `locationName:"maxRetries" type:"integer" required:"true"`

	// A collection of messages that Amazon Lex can send to the user. Amazon Lex
	// chooses the actual message to send at runtime.
	//
	// MessageGroups is a required field
	MessageGroups []*MessageGroup `locationName:"messageGroups" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetAllowInterrupt sets the AllowInterrupt field's value.
func (s *PromptSpecification) SetAllowInterrupt(v bool) *PromptSpecification {
	s.AllowInterrupt = &v
	return s
}

// SetMaxRetries sets the MaxRetries field's value.
func (s *PromptSpecification) SetMaxRetries(v int64) *PromptSpecification {
	s.MaxRetries = &v
	return s
}

// SetMessageGroups sets the MessageGroups field's value.
func (s *PromptSpecification) SetMessageGroups(v []*MessageGroup) *PromptSpecification {
	s.MessageGroups = v
	return s
}

type ResourceNotFoundException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

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

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

func newErrorResourceNotFoundException(v protocol.ResponseMetadata) error {
	return &ResourceNotFoundException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *ResourceNotFoundException) Code() string {
	return "ResourceNotFoundException"
}

// Message returns the exception's message.
func (s *ResourceNotFoundException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ResourceNotFoundException) OrigErr() error {
	return nil
}

func (s *ResourceNotFoundException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *ResourceNotFoundException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *ResourceNotFoundException) RequestID() string {
	return s.RespMetadata.RequestID
}

// Specifies a list of message groups that Amazon Lex uses to respond the user
// input.
type ResponseSpecification struct {
	_ struct{} `type:"structure"`

	// Indicates whether the user can interrupt a speech response from Amazon Lex.
	AllowInterrupt *bool `locationName:"allowInterrupt" type:"boolean"`

	// A collection of responses that Amazon Lex can send to the user. Amazon Lex
	// chooses the actual response to send at runtime.
	//
	// MessageGroups is a required field
	MessageGroups []*MessageGroup `locationName:"messageGroups" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetAllowInterrupt sets the AllowInterrupt field's value.
func (s *ResponseSpecification) SetAllowInterrupt(v bool) *ResponseSpecification {
	s.AllowInterrupt = &v
	return s
}

// SetMessageGroups sets the MessageGroups field's value.
func (s *ResponseSpecification) SetMessageGroups(v []*MessageGroup) *ResponseSpecification {
	s.MessageGroups = v
	return s
}

// Specifies an Amazon S3 bucket for logging audio conversations
type S3BucketLogDestination struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of an AWS Key Management Service (KMS) key
	// for encrypting audio log files stored in an S3 bucket.
	KmsKeyArn *string `locationName:"kmsKeyArn" min:"20" type:"string"`

	// The S3 prefix to assign to audio log files.
	//
	// LogPrefix is a required field
	LogPrefix *string `locationName:"logPrefix" type:"string" required:"true"`

	// The Amazon Resource Name (ARN) of an Amazon S3 bucket where audio log files
	// are stored.
	//
	// S3BucketArn is a required field
	S3BucketArn *string `locationName:"s3BucketArn" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetKmsKeyArn sets the KmsKeyArn field's value.
func (s *S3BucketLogDestination) SetKmsKeyArn(v string) *S3BucketLogDestination {
	s.KmsKeyArn = &v
	return s
}

// SetLogPrefix sets the LogPrefix field's value.
func (s *S3BucketLogDestination) SetLogPrefix(v string) *S3BucketLogDestination {
	s.LogPrefix = &v
	return s
}

// SetS3BucketArn sets the S3BucketArn field's value.
func (s *S3BucketLogDestination) SetS3BucketArn(v string) *S3BucketLogDestination {
	s.S3BucketArn = &v
	return s
}

// Defines a Speech Synthesis Markup Language (SSML) prompt.
type SSMLMessage struct {
	_ struct{} `type:"structure"`

	// The SSML text that defines the prompt.
	//
	// Value is a required field
	Value *string `locationName:"value" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetValue sets the Value field's value.
func (s *SSMLMessage) SetValue(v string) *SSMLMessage {
	s.Value = &v
	return s
}

// A sample utterance that invokes an intent or respond to a slot elicitation
// prompt.
type SampleUtterance struct {
	_ struct{} `type:"structure"`

	// The sample utterance that Amazon Lex uses to build its machine-learning model
	// to recognize intents.
	//
	// Utterance is a required field
	Utterance *string `locationName:"utterance" type:"string" required:"true"`
}

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

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

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

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

// SetUtterance sets the Utterance field's value.
func (s *SampleUtterance) SetUtterance(v string) *SampleUtterance {
	s.Utterance = &v
	return s
}

// Defines one of the values for a slot type.
type SampleValue struct {
	_ struct{} `type:"structure"`

	// The value that can be used for a slot type.
	//
	// Value is a required field
	Value *string `locationName:"value" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetValue sets the Value field's value.
func (s *SampleValue) SetValue(v string) *SampleValue {
	s.Value = &v
	return s
}

// Determines whether Amazon Lex will use Amazon Comprehend to detect the sentiment
// of user utterances.
type SentimentAnalysisSettings struct {
	_ struct{} `type:"structure"`

	// Sets whether Amazon Lex uses Amazon Comprehend to detect the sentiment of
	// user utterances.
	//
	// DetectSentiment is a required field
	DetectSentiment *bool `locationName:"detectSentiment" type:"boolean" required:"true"`
}

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

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

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

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

// SetDetectSentiment sets the DetectSentiment field's value.
func (s *SentimentAnalysisSettings) SetDetectSentiment(v bool) *SentimentAnalysisSettings {
	s.DetectSentiment = &v
	return s
}

type ServiceQuotaExceededException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

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

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

func newErrorServiceQuotaExceededException(v protocol.ResponseMetadata) error {
	return &ServiceQuotaExceededException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *ServiceQuotaExceededException) Code() string {
	return "ServiceQuotaExceededException"
}

// Message returns the exception's message.
func (s *ServiceQuotaExceededException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ServiceQuotaExceededException) OrigErr() error {
	return nil
}

func (s *ServiceQuotaExceededException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *ServiceQuotaExceededException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *ServiceQuotaExceededException) RequestID() string {
	return s.RespMetadata.RequestID
}

// Specifies the default value to use when a user doesn't provide a value for
// a slot.
type SlotDefaultValue struct {
	_ struct{} `type:"structure"`

	// The default value to use when a user doesn't provide a value for a slot.
	//
	// DefaultValue is a required field
	DefaultValue *string `locationName:"defaultValue" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetDefaultValue sets the DefaultValue field's value.
func (s *SlotDefaultValue) SetDefaultValue(v string) *SlotDefaultValue {
	s.DefaultValue = &v
	return s
}

// Defines a list of values that Amazon Lex should use as the default value
// for a slot.
type SlotDefaultValueSpecification struct {
	_ struct{} `type:"structure"`

	// A list of default values. Amazon Lex chooses the default value to use in
	// the order that they are presented in the list.
	//
	// DefaultValueList is a required field
	DefaultValueList []*SlotDefaultValue `locationName:"defaultValueList" type:"list" required:"true"`
}

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

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

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

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

// SetDefaultValueList sets the DefaultValueList field's value.
func (s *SlotDefaultValueSpecification) SetDefaultValueList(v []*SlotDefaultValue) *SlotDefaultValueSpecification {
	s.DefaultValueList = v
	return s
}

// Filters the response from the ListSlots operation.
type SlotFilter struct {
	_ struct{} `type:"structure"`

	// The name of the field to use for filtering.
	//
	// Name is a required field
	Name *string `locationName:"name" type:"string" required:"true" enum:"SlotFilterName"`

	// The operator to use for the filter. Specify EQ when the ListSlots operation
	// should return only aliases that equal the specified value. Specify CO when
	// the ListSlots operation should return aliases that contain the specified
	// value.
	//
	// Operator is a required field
	Operator *string `locationName:"operator" type:"string" required:"true" enum:"SlotFilterOperator"`

	// The value to use to filter the response.
	//
	// Values is a required field
	Values []*string `locationName:"values" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetName sets the Name field's value.
func (s *SlotFilter) SetName(v string) *SlotFilter {
	s.Name = &v
	return s
}

// SetOperator sets the Operator field's value.
func (s *SlotFilter) SetOperator(v string) *SlotFilter {
	s.Operator = &v
	return s
}

// SetValues sets the Values field's value.
func (s *SlotFilter) SetValues(v []*string) *SlotFilter {
	s.Values = v
	return s
}

// Sets the priority that Amazon Lex should use when eliciting slot values from
// a user.
type SlotPriority struct {
	_ struct{} `type:"structure"`

	// The priority that a slot should be elicited.
	//
	// Priority is a required field
	Priority *int64 `locationName:"priority" type:"integer" required:"true"`

	// The unique identifier of the slot.
	//
	// SlotId is a required field
	SlotId *string `locationName:"slotId" min:"10" type:"string" required:"true"`
}

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

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

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

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

// SetPriority sets the Priority field's value.
func (s *SlotPriority) SetPriority(v int64) *SlotPriority {
	s.Priority = &v
	return s
}

// SetSlotId sets the SlotId field's value.
func (s *SlotPriority) SetSlotId(v string) *SlotPriority {
	s.SlotId = &v
	return s
}

// Specifies attributes for sorting a list of bots.
type SlotSortBy struct {
	_ struct{} `type:"structure"`

	// The attribute to use to sort the list.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"SlotSortAttribute"`

	// The order to sort the list. You can choose ascending or descending.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *SlotSortBy) SetAttribute(v string) *SlotSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *SlotSortBy) SetOrder(v string) *SlotSortBy {
	s.Order = &v
	return s
}

// Summary information about a slot, a value that the bot elicits from the user.
type SlotSummary struct {
	_ struct{} `type:"structure"`

	// The description of the slot.
	Description *string `locationName:"description" type:"string"`

	// The timestamp of the last date and time that the slot was updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// Whether the slot is required or optional. An intent is complete when all
	// required slots are filled.
	SlotConstraint *string `locationName:"slotConstraint" type:"string" enum:"SlotConstraint"`

	// The unique identifier of the slot.
	SlotId *string `locationName:"slotId" min:"10" type:"string"`

	// The name given to the slot.
	SlotName *string `locationName:"slotName" min:"1" type:"string"`

	// The unique identifier for the slot type that defines the values for the slot.
	SlotTypeId *string `locationName:"slotTypeId" min:"1" type:"string"`

	// Prompts that are sent to the user to elicit a value for the slot.
	ValueElicitationPromptSpecification *PromptSpecification `locationName:"valueElicitationPromptSpecification" type:"structure"`
}

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

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

// SetDescription sets the Description field's value.
func (s *SlotSummary) SetDescription(v string) *SlotSummary {
	s.Description = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *SlotSummary) SetLastUpdatedDateTime(v time.Time) *SlotSummary {
	s.LastUpdatedDateTime = &v
	return s
}

// SetSlotConstraint sets the SlotConstraint field's value.
func (s *SlotSummary) SetSlotConstraint(v string) *SlotSummary {
	s.SlotConstraint = &v
	return s
}

// SetSlotId sets the SlotId field's value.
func (s *SlotSummary) SetSlotId(v string) *SlotSummary {
	s.SlotId = &v
	return s
}

// SetSlotName sets the SlotName field's value.
func (s *SlotSummary) SetSlotName(v string) *SlotSummary {
	s.SlotName = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *SlotSummary) SetSlotTypeId(v string) *SlotSummary {
	s.SlotTypeId = &v
	return s
}

// SetValueElicitationPromptSpecification sets the ValueElicitationPromptSpecification field's value.
func (s *SlotSummary) SetValueElicitationPromptSpecification(v *PromptSpecification) *SlotSummary {
	s.ValueElicitationPromptSpecification = v
	return s
}

// Filters the response from the ListSlotTypes operation.
type SlotTypeFilter struct {
	_ struct{} `type:"structure"`

	// The name of the field to use for filtering.
	//
	// Name is a required field
	Name *string `locationName:"name" type:"string" required:"true" enum:"SlotTypeFilterName"`

	// The operator to use for the filter. Specify EQ when the ListSlotTypes operation
	// should return only aliases that equal the specified value. Specify CO when
	// the ListSlotTypes operation should return aliases that contain the specified
	// value.
	//
	// Operator is a required field
	Operator *string `locationName:"operator" type:"string" required:"true" enum:"SlotTypeFilterOperator"`

	// The value to use to filter the response.
	//
	// Values is a required field
	Values []*string `locationName:"values" min:"1" type:"list" required:"true"`
}

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

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

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

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

// SetName sets the Name field's value.
func (s *SlotTypeFilter) SetName(v string) *SlotTypeFilter {
	s.Name = &v
	return s
}

// SetOperator sets the Operator field's value.
func (s *SlotTypeFilter) SetOperator(v string) *SlotTypeFilter {
	s.Operator = &v
	return s
}

// SetValues sets the Values field's value.
func (s *SlotTypeFilter) SetValues(v []*string) *SlotTypeFilter {
	s.Values = v
	return s
}

// Specifies attributes for sorting a list of slot types.
type SlotTypeSortBy struct {
	_ struct{} `type:"structure"`

	// The attribute to use to sort the list of slot types.
	//
	// Attribute is a required field
	Attribute *string `locationName:"attribute" type:"string" required:"true" enum:"SlotTypeSortAttribute"`

	// The order to sort the list. You can say ascending or descending.
	//
	// Order is a required field
	Order *string `locationName:"order" type:"string" required:"true" enum:"SortOrder"`
}

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

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

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

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

// SetAttribute sets the Attribute field's value.
func (s *SlotTypeSortBy) SetAttribute(v string) *SlotTypeSortBy {
	s.Attribute = &v
	return s
}

// SetOrder sets the Order field's value.
func (s *SlotTypeSortBy) SetOrder(v string) *SlotTypeSortBy {
	s.Order = &v
	return s
}

// Provides summary information about a slot type.
type SlotTypeSummary struct {
	_ struct{} `type:"structure"`

	// The description of the slot type.
	Description *string `locationName:"description" type:"string"`

	// A timestamp of the date and time that the slot type was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// If the slot type is derived from a built-on slot type, the name of the parent
	// slot type.
	ParentSlotTypeSignature *string `locationName:"parentSlotTypeSignature" type:"string"`

	// The unique identifier assigned to the slot type.
	SlotTypeId *string `locationName:"slotTypeId" min:"10" type:"string"`

	// The name of the slot type.
	SlotTypeName *string `locationName:"slotTypeName" min:"1" type:"string"`
}

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

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

// SetDescription sets the Description field's value.
func (s *SlotTypeSummary) SetDescription(v string) *SlotTypeSummary {
	s.Description = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *SlotTypeSummary) SetLastUpdatedDateTime(v time.Time) *SlotTypeSummary {
	s.LastUpdatedDateTime = &v
	return s
}

// SetParentSlotTypeSignature sets the ParentSlotTypeSignature field's value.
func (s *SlotTypeSummary) SetParentSlotTypeSignature(v string) *SlotTypeSummary {
	s.ParentSlotTypeSignature = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *SlotTypeSummary) SetSlotTypeId(v string) *SlotTypeSummary {
	s.SlotTypeId = &v
	return s
}

// SetSlotTypeName sets the SlotTypeName field's value.
func (s *SlotTypeSummary) SetSlotTypeName(v string) *SlotTypeSummary {
	s.SlotTypeName = &v
	return s
}

// Each slot type can have a set of values. Each SlotTypeValue represents a
// value that the slot type can take.
type SlotTypeValue struct {
	_ struct{} `type:"structure"`

	// The value of the slot type entry.
	SampleValue *SampleValue `locationName:"sampleValue" type:"structure"`

	// Additional values releated to the slot type entry.
	Synonyms []*SampleValue `locationName:"synonyms" min:"1" type:"list"`
}

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

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

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

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

// SetSampleValue sets the SampleValue field's value.
func (s *SlotTypeValue) SetSampleValue(v *SampleValue) *SlotTypeValue {
	s.SampleValue = v
	return s
}

// SetSynonyms sets the Synonyms field's value.
func (s *SlotTypeValue) SetSynonyms(v []*SampleValue) *SlotTypeValue {
	s.Synonyms = v
	return s
}

// Settings that you can use for eliciting a slot value.
type SlotValueElicitationSetting struct {
	_ struct{} `type:"structure"`

	// A list of default values for a slot. Default values are used when Amazon
	// Lex hasn't determined a value for a slot. You can specify default values
	// from context variables, sesion attributes, and defined values.
	DefaultValueSpecification *SlotDefaultValueSpecification `locationName:"defaultValueSpecification" type:"structure"`

	// The prompt that Amazon Lex uses to elicit the slot value from the user.
	PromptSpecification *PromptSpecification `locationName:"promptSpecification" type:"structure"`

	// If you know a specific pattern that users might respond to an Amazon Lex
	// request for a slot value, you can provide those utterances to improve accuracy.
	// This is optional. In most cases, Amazon Lex is capable of understanding user
	// utterances.
	SampleUtterances []*SampleUtterance `locationName:"sampleUtterances" type:"list"`

	// Specifies whether the slot is required or optional.
	//
	// SlotConstraint is a required field
	SlotConstraint *string `locationName:"slotConstraint" type:"string" required:"true" enum:"SlotConstraint"`

	// Specifies the prompts that Amazon Lex uses while a bot is waiting for customer
	// input.
	WaitAndContinueSpecification *WaitAndContinueSpecification `locationName:"waitAndContinueSpecification" type:"structure"`
}

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

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

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

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

// SetDefaultValueSpecification sets the DefaultValueSpecification field's value.
func (s *SlotValueElicitationSetting) SetDefaultValueSpecification(v *SlotDefaultValueSpecification) *SlotValueElicitationSetting {
	s.DefaultValueSpecification = v
	return s
}

// SetPromptSpecification sets the PromptSpecification field's value.
func (s *SlotValueElicitationSetting) SetPromptSpecification(v *PromptSpecification) *SlotValueElicitationSetting {
	s.PromptSpecification = v
	return s
}

// SetSampleUtterances sets the SampleUtterances field's value.
func (s *SlotValueElicitationSetting) SetSampleUtterances(v []*SampleUtterance) *SlotValueElicitationSetting {
	s.SampleUtterances = v
	return s
}

// SetSlotConstraint sets the SlotConstraint field's value.
func (s *SlotValueElicitationSetting) SetSlotConstraint(v string) *SlotValueElicitationSetting {
	s.SlotConstraint = &v
	return s
}

// SetWaitAndContinueSpecification sets the WaitAndContinueSpecification field's value.
func (s *SlotValueElicitationSetting) SetWaitAndContinueSpecification(v *WaitAndContinueSpecification) *SlotValueElicitationSetting {
	s.WaitAndContinueSpecification = v
	return s
}

// Provides a regular expression used to validate the value of a slot.
type SlotValueRegexFilter struct {
	_ struct{} `type:"structure"`

	// A regular expression used to validate the value of a slot.
	//
	// Use a standard regular expression. Amazon Lex supports the following characters
	// in the regular expression:
	//
	//    * A-Z, a-z
	//
	//    * 0-9
	//
	//    * Unicode characters ("\ u<Unicode>")
	//
	// Represent Unicode characters with four digits, for example "\u0041" or "\u005A".
	//
	// The following regular expression operators are not supported:
	//
	//    * Infinite repeaters: *, +, or {x,} with no upper bound.
	//
	//    * Wild card (.)
	//
	// Pattern is a required field
	Pattern *string `locationName:"pattern" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetPattern sets the Pattern field's value.
func (s *SlotValueRegexFilter) SetPattern(v string) *SlotValueRegexFilter {
	s.Pattern = &v
	return s
}

// Contains settings used by Amazon Lex to select a slot value.
type SlotValueSelectionSetting struct {
	_ struct{} `type:"structure"`

	// A regular expression used to validate the value of a slot.
	RegexFilter *SlotValueRegexFilter `locationName:"regexFilter" type:"structure"`

	// Determines the slot resolution strategy that Amazon Lex uses to return slot
	// type values. The field can be set to one of the following values:
	//
	//    * OriginalValue - Returns the value entered by the user, if the user value
	//    is similar to the slot value.
	//
	//    * TopResolution - If there is a resolution list for the slot, return the
	//    first value in the resolution list as the slot type value. If there is
	//    no resolution list, null is returned.
	//
	// If you don't specify the valueSelectionStrategy, the default is OriginalValue.
	//
	// ResolutionStrategy is a required field
	ResolutionStrategy *string `locationName:"resolutionStrategy" type:"string" required:"true" enum:"SlotValueResolutionStrategy"`
}

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

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

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

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

// SetRegexFilter sets the RegexFilter field's value.
func (s *SlotValueSelectionSetting) SetRegexFilter(v *SlotValueRegexFilter) *SlotValueSelectionSetting {
	s.RegexFilter = v
	return s
}

// SetResolutionStrategy sets the ResolutionStrategy field's value.
func (s *SlotValueSelectionSetting) SetResolutionStrategy(v string) *SlotValueSelectionSetting {
	s.ResolutionStrategy = &v
	return s
}

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

	// The password used to encrypt the zip archive that contains the bot or bot
	// locale definition. You should always encrypt the zip archive to protect it
	// during transit between your site and Amazon Lex.
	FilePassword *string `locationName:"filePassword" min:"1" type:"string" sensitive:"true"`

	// The unique identifier for the import. It is included in the response from
	// the operation.
	//
	// ImportId is a required field
	ImportId *string `locationName:"importId" min:"10" type:"string" required:"true"`

	// The strategy to use when there is a name conflict between the imported resource
	// and an existing resource. When the merge strategy is FailOnConflict existing
	// resources are not overwritten and the import fails.
	//
	// MergeStrategy is a required field
	MergeStrategy *string `locationName:"mergeStrategy" type:"string" required:"true" enum:"MergeStrategy"`

	// Parameters for creating the bot or bot locale.
	//
	// ResourceSpecification is a required field
	ResourceSpecification *ImportResourceSpecification `locationName:"resourceSpecification" type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *StartImportInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "StartImportInput"}
	if s.FilePassword != nil && len(*s.FilePassword) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("FilePassword", 1))
	}
	if s.ImportId == nil {
		invalidParams.Add(request.NewErrParamRequired("ImportId"))
	}
	if s.ImportId != nil && len(*s.ImportId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("ImportId", 10))
	}
	if s.MergeStrategy == nil {
		invalidParams.Add(request.NewErrParamRequired("MergeStrategy"))
	}
	if s.ResourceSpecification == nil {
		invalidParams.Add(request.NewErrParamRequired("ResourceSpecification"))
	}
	if s.ResourceSpecification != nil {
		if err := s.ResourceSpecification.Validate(); err != nil {
			invalidParams.AddNested("ResourceSpecification", err.(request.ErrInvalidParams))
		}
	}

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

// SetFilePassword sets the FilePassword field's value.
func (s *StartImportInput) SetFilePassword(v string) *StartImportInput {
	s.FilePassword = &v
	return s
}

// SetImportId sets the ImportId field's value.
func (s *StartImportInput) SetImportId(v string) *StartImportInput {
	s.ImportId = &v
	return s
}

// SetMergeStrategy sets the MergeStrategy field's value.
func (s *StartImportInput) SetMergeStrategy(v string) *StartImportInput {
	s.MergeStrategy = &v
	return s
}

// SetResourceSpecification sets the ResourceSpecification field's value.
func (s *StartImportInput) SetResourceSpecification(v *ImportResourceSpecification) *StartImportInput {
	s.ResourceSpecification = v
	return s
}

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

	// The date and time that the import request was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// A unique identifier for the import.
	ImportId *string `locationName:"importId" min:"10" type:"string"`

	// The current status of the import. When the status is Complete the bot or
	// bot alias is ready to use.
	ImportStatus *string `locationName:"importStatus" type:"string" enum:"ImportStatus"`

	// The strategy used when there was a name conflict between the imported resource
	// and an existing resource. When the merge strategy is FailOnConflict existing
	// resources are not overwritten and the import fails.
	MergeStrategy *string `locationName:"mergeStrategy" type:"string" enum:"MergeStrategy"`

	// The parameters used when importing the bot or bot locale.
	ResourceSpecification *ImportResourceSpecification `locationName:"resourceSpecification" type:"structure"`
}

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

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

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *StartImportOutput) SetCreationDateTime(v time.Time) *StartImportOutput {
	s.CreationDateTime = &v
	return s
}

// SetImportId sets the ImportId field's value.
func (s *StartImportOutput) SetImportId(v string) *StartImportOutput {
	s.ImportId = &v
	return s
}

// SetImportStatus sets the ImportStatus field's value.
func (s *StartImportOutput) SetImportStatus(v string) *StartImportOutput {
	s.ImportStatus = &v
	return s
}

// SetMergeStrategy sets the MergeStrategy field's value.
func (s *StartImportOutput) SetMergeStrategy(v string) *StartImportOutput {
	s.MergeStrategy = &v
	return s
}

// SetResourceSpecification sets the ResourceSpecification field's value.
func (s *StartImportOutput) SetResourceSpecification(v *ImportResourceSpecification) *StartImportOutput {
	s.ResourceSpecification = v
	return s
}

// Defines the messages that Amazon Lex sends to a user to remind them that
// the bot is waiting for a response.
type StillWaitingResponseSpecification struct {
	_ struct{} `type:"structure"`

	// Indicates that the user can interrupt the response by speaking while the
	// message is being played.
	AllowInterrupt *bool `locationName:"allowInterrupt" type:"boolean"`

	// How often a message should be sent to the user. Minimum of 1 second, maximum
	// of 5 minutes.
	//
	// FrequencyInSeconds is a required field
	FrequencyInSeconds *int64 `locationName:"frequencyInSeconds" min:"1" type:"integer" required:"true"`

	// One or more message groups, each containing one or more messages, that define
	// the prompts that Amazon Lex sends to the user.
	//
	// MessageGroups is a required field
	MessageGroups []*MessageGroup `locationName:"messageGroups" min:"1" type:"list" required:"true"`

	// If Amazon Lex waits longer than this length of time for a response, it will
	// stop sending messages.
	//
	// TimeoutInSeconds is a required field
	TimeoutInSeconds *int64 `locationName:"timeoutInSeconds" min:"1" type:"integer" required:"true"`
}

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

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

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

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

// SetAllowInterrupt sets the AllowInterrupt field's value.
func (s *StillWaitingResponseSpecification) SetAllowInterrupt(v bool) *StillWaitingResponseSpecification {
	s.AllowInterrupt = &v
	return s
}

// SetFrequencyInSeconds sets the FrequencyInSeconds field's value.
func (s *StillWaitingResponseSpecification) SetFrequencyInSeconds(v int64) *StillWaitingResponseSpecification {
	s.FrequencyInSeconds = &v
	return s
}

// SetMessageGroups sets the MessageGroups field's value.
func (s *StillWaitingResponseSpecification) SetMessageGroups(v []*MessageGroup) *StillWaitingResponseSpecification {
	s.MessageGroups = v
	return s
}

// SetTimeoutInSeconds sets the TimeoutInSeconds field's value.
func (s *StillWaitingResponseSpecification) SetTimeoutInSeconds(v int64) *StillWaitingResponseSpecification {
	s.TimeoutInSeconds = &v
	return s
}

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

	// The Amazon Resource Name (ARN) of the bot, bot alias, or bot channel to tag.
	//
	// ResourceARN is a required field
	ResourceARN *string `location:"uri" locationName:"resourceARN" min:"1" type:"string" required:"true"`

	// A list of tag keys to add to the resource. If a tag key already exists, the
	// existing value is replaced with the new value.
	//
	// Tags is a required field
	Tags map[string]*string `locationName:"tags" type:"map" required:"true"`
}

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

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

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

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

// SetResourceARN sets the ResourceARN field's value.
func (s *TagResourceInput) SetResourceARN(v string) *TagResourceInput {
	s.ResourceARN = &v
	return s
}

// SetTags sets the Tags field's value.
func (s *TagResourceInput) SetTags(v map[string]*string) *TagResourceInput {
	s.Tags = v
	return s
}

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

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

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

// Defines the Amazon CloudWatch Logs destination log group for conversation
// text logs.
type TextLogDestination struct {
	_ struct{} `type:"structure"`

	// Defines the Amazon CloudWatch Logs log group where text and metadata logs
	// are delivered.
	//
	// CloudWatch is a required field
	CloudWatch *CloudWatchLogGroupLogDestination `locationName:"cloudWatch" type:"structure" required:"true"`
}

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

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

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

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

// SetCloudWatch sets the CloudWatch field's value.
func (s *TextLogDestination) SetCloudWatch(v *CloudWatchLogGroupLogDestination) *TextLogDestination {
	s.CloudWatch = v
	return s
}

// Defines settings to enable text conversation logs.
type TextLogSetting struct {
	_ struct{} `type:"structure"`

	// Defines the Amazon CloudWatch Logs destination log group for conversation
	// text logs.
	//
	// Destination is a required field
	Destination *TextLogDestination `locationName:"destination" type:"structure" required:"true"`

	// Determines whether conversation logs should be stored for an alias.
	//
	// Enabled is a required field
	Enabled *bool `locationName:"enabled" type:"boolean" required:"true"`
}

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

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

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

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

// SetDestination sets the Destination field's value.
func (s *TextLogSetting) SetDestination(v *TextLogDestination) *TextLogSetting {
	s.Destination = v
	return s
}

// SetEnabled sets the Enabled field's value.
func (s *TextLogSetting) SetEnabled(v bool) *TextLogSetting {
	s.Enabled = &v
	return s
}

type ThrottlingException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`

	RetryAfterSeconds *int64 `location:"header" locationName:"Retry-After" type:"integer"`
}

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

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

func newErrorThrottlingException(v protocol.ResponseMetadata) error {
	return &ThrottlingException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *ThrottlingException) Code() string {
	return "ThrottlingException"
}

// Message returns the exception's message.
func (s *ThrottlingException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ThrottlingException) OrigErr() error {
	return nil
}

func (s *ThrottlingException) Error() string {
	return fmt.Sprintf("%s: %s\n%s", s.Code(), s.Message(), s.String())
}

// Status code returns the HTTP status code for the request's response error.
func (s *ThrottlingException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *ThrottlingException) RequestID() string {
	return s.RespMetadata.RequestID
}

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

	// The Amazon Resource Name (ARN) of the resource to remove the tags from.
	//
	// ResourceARN is a required field
	ResourceARN *string `location:"uri" locationName:"resourceARN" min:"1" type:"string" required:"true"`

	// A list of tag keys to remove from the resource. If a tag key does not exist
	// on the resource, it is ignored.
	//
	// TagKeys is a required field
	TagKeys []*string `location:"querystring" locationName:"tagKeys" type:"list" required:"true"`
}

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

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

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

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

// SetResourceARN sets the ResourceARN field's value.
func (s *UntagResourceInput) SetResourceARN(v string) *UntagResourceInput {
	s.ResourceARN = &v
	return s
}

// SetTagKeys sets the TagKeys field's value.
func (s *UntagResourceInput) SetTagKeys(v []*string) *UntagResourceInput {
	s.TagKeys = v
	return s
}

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

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

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

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

	// The unique identifier of the bot alias.
	//
	// BotAliasId is a required field
	BotAliasId *string `location:"uri" locationName:"botAliasId" min:"10" type:"string" required:"true"`

	// The new Lambda functions to use in each locale for the bot alias.
	BotAliasLocaleSettings map[string]*BotAliasLocaleSettings `locationName:"botAliasLocaleSettings" min:"1" type:"map"`

	// The new name to assign to the bot alias.
	//
	// BotAliasName is a required field
	BotAliasName *string `locationName:"botAliasName" min:"1" type:"string" required:"true"`

	// The identifier of the bot with the updated alias.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The new bot version to assign to the bot alias.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// The new settings for storing conversation logs in Amazon CloudWatch Logs
	// and Amazon S3 buckets.
	ConversationLogSettings *ConversationLogSettings `locationName:"conversationLogSettings" type:"structure"`

	// The new description to assign to the bot alias.
	Description *string `locationName:"description" type:"string"`

	// Determines whether Amazon Lex will use Amazon Comprehend to detect the sentiment
	// of user utterances.
	SentimentAnalysisSettings *SentimentAnalysisSettings `locationName:"sentimentAnalysisSettings" type:"structure"`
}

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

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

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

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

// SetBotAliasId sets the BotAliasId field's value.
func (s *UpdateBotAliasInput) SetBotAliasId(v string) *UpdateBotAliasInput {
	s.BotAliasId = &v
	return s
}

// SetBotAliasLocaleSettings sets the BotAliasLocaleSettings field's value.
func (s *UpdateBotAliasInput) SetBotAliasLocaleSettings(v map[string]*BotAliasLocaleSettings) *UpdateBotAliasInput {
	s.BotAliasLocaleSettings = v
	return s
}

// SetBotAliasName sets the BotAliasName field's value.
func (s *UpdateBotAliasInput) SetBotAliasName(v string) *UpdateBotAliasInput {
	s.BotAliasName = &v
	return s
}

// SetBotId sets the BotId field's value.
func (s *UpdateBotAliasInput) SetBotId(v string) *UpdateBotAliasInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateBotAliasInput) SetBotVersion(v string) *UpdateBotAliasInput {
	s.BotVersion = &v
	return s
}

// SetConversationLogSettings sets the ConversationLogSettings field's value.
func (s *UpdateBotAliasInput) SetConversationLogSettings(v *ConversationLogSettings) *UpdateBotAliasInput {
	s.ConversationLogSettings = v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateBotAliasInput) SetDescription(v string) *UpdateBotAliasInput {
	s.Description = &v
	return s
}

// SetSentimentAnalysisSettings sets the SentimentAnalysisSettings field's value.
func (s *UpdateBotAliasInput) SetSentimentAnalysisSettings(v *SentimentAnalysisSettings) *UpdateBotAliasInput {
	s.SentimentAnalysisSettings = v
	return s
}

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

	// The identifier of the updated bot alias.
	BotAliasId *string `locationName:"botAliasId" min:"10" type:"string"`

	// The updated Lambda functions to use in each locale for the bot alias.
	BotAliasLocaleSettings map[string]*BotAliasLocaleSettings `locationName:"botAliasLocaleSettings" min:"1" type:"map"`

	// The updated name of the bot alias.
	BotAliasName *string `locationName:"botAliasName" min:"1" type:"string"`

	// The current status of the bot alias. When the status is Available the alias
	// is ready for use.
	BotAliasStatus *string `locationName:"botAliasStatus" type:"string" enum:"BotAliasStatus"`

	// The identifier of the bot with the updated alias.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The updated version of the bot that the alias points to.
	BotVersion *string `locationName:"botVersion" min:"1" type:"string"`

	// The updated settings for storing conversation logs in Amazon CloudWatch Logs
	// and Amazon S3 buckets.
	ConversationLogSettings *ConversationLogSettings `locationName:"conversationLogSettings" type:"structure"`

	// A timestamp of the date and time that the bot was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The updated description of the bot alias.
	Description *string `locationName:"description" type:"string"`

	// A timestamp of the date and time that the bot was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// Determines whether Amazon Lex will use Amazon Comprehend to detect the sentiment
	// of user utterances.
	SentimentAnalysisSettings *SentimentAnalysisSettings `locationName:"sentimentAnalysisSettings" type:"structure"`
}

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

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

// SetBotAliasId sets the BotAliasId field's value.
func (s *UpdateBotAliasOutput) SetBotAliasId(v string) *UpdateBotAliasOutput {
	s.BotAliasId = &v
	return s
}

// SetBotAliasLocaleSettings sets the BotAliasLocaleSettings field's value.
func (s *UpdateBotAliasOutput) SetBotAliasLocaleSettings(v map[string]*BotAliasLocaleSettings) *UpdateBotAliasOutput {
	s.BotAliasLocaleSettings = v
	return s
}

// SetBotAliasName sets the BotAliasName field's value.
func (s *UpdateBotAliasOutput) SetBotAliasName(v string) *UpdateBotAliasOutput {
	s.BotAliasName = &v
	return s
}

// SetBotAliasStatus sets the BotAliasStatus field's value.
func (s *UpdateBotAliasOutput) SetBotAliasStatus(v string) *UpdateBotAliasOutput {
	s.BotAliasStatus = &v
	return s
}

// SetBotId sets the BotId field's value.
func (s *UpdateBotAliasOutput) SetBotId(v string) *UpdateBotAliasOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateBotAliasOutput) SetBotVersion(v string) *UpdateBotAliasOutput {
	s.BotVersion = &v
	return s
}

// SetConversationLogSettings sets the ConversationLogSettings field's value.
func (s *UpdateBotAliasOutput) SetConversationLogSettings(v *ConversationLogSettings) *UpdateBotAliasOutput {
	s.ConversationLogSettings = v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *UpdateBotAliasOutput) SetCreationDateTime(v time.Time) *UpdateBotAliasOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateBotAliasOutput) SetDescription(v string) *UpdateBotAliasOutput {
	s.Description = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *UpdateBotAliasOutput) SetLastUpdatedDateTime(v time.Time) *UpdateBotAliasOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetSentimentAnalysisSettings sets the SentimentAnalysisSettings field's value.
func (s *UpdateBotAliasOutput) SetSentimentAnalysisSettings(v *SentimentAnalysisSettings) *UpdateBotAliasOutput {
	s.SentimentAnalysisSettings = v
	return s
}

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

	// The unique identifier of the bot to update. This identifier is returned by
	// the CreateBot operation.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The new name of the bot. The name must be unique in the account that creates
	// the bot.
	//
	// BotName is a required field
	BotName *string `locationName:"botName" min:"1" type:"string" required:"true"`

	// Provides information on additional privacy protections Amazon Lex should
	// use with the bot's data.
	//
	// DataPrivacy is a required field
	DataPrivacy *DataPrivacy `locationName:"dataPrivacy" type:"structure" required:"true"`

	// A description of the bot.
	Description *string `locationName:"description" type:"string"`

	// The time, in seconds, that Amazon Lex should keep information about a user's
	// conversation with the bot.
	//
	// A user interaction remains active for the amount of time specified. If no
	// conversation occurs during this time, the session expires and Amazon Lex
	// deletes any data provided before the timeout.
	//
	// You can specify between 60 (1 minute) and 86,400 (24 hours) seconds.
	//
	// IdleSessionTTLInSeconds is a required field
	IdleSessionTTLInSeconds *int64 `locationName:"idleSessionTTLInSeconds" min:"60" type:"integer" required:"true"`

	// The Amazon Resource Name (ARN) of an IAM role that has permissions to access
	// the bot.
	//
	// RoleArn is a required field
	RoleArn *string `locationName:"roleArn" min:"32" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateBotInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "UpdateBotInput"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotName == nil {
		invalidParams.Add(request.NewErrParamRequired("BotName"))
	}
	if s.BotName != nil && len(*s.BotName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("BotName", 1))
	}
	if s.DataPrivacy == nil {
		invalidParams.Add(request.NewErrParamRequired("DataPrivacy"))
	}
	if s.IdleSessionTTLInSeconds == nil {
		invalidParams.Add(request.NewErrParamRequired("IdleSessionTTLInSeconds"))
	}
	if s.IdleSessionTTLInSeconds != nil && *s.IdleSessionTTLInSeconds < 60 {
		invalidParams.Add(request.NewErrParamMinValue("IdleSessionTTLInSeconds", 60))
	}
	if s.RoleArn == nil {
		invalidParams.Add(request.NewErrParamRequired("RoleArn"))
	}
	if s.RoleArn != nil && len(*s.RoleArn) < 32 {
		invalidParams.Add(request.NewErrParamMinLen("RoleArn", 32))
	}
	if s.DataPrivacy != nil {
		if err := s.DataPrivacy.Validate(); err != nil {
			invalidParams.AddNested("DataPrivacy", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *UpdateBotInput) SetBotId(v string) *UpdateBotInput {
	s.BotId = &v
	return s
}

// SetBotName sets the BotName field's value.
func (s *UpdateBotInput) SetBotName(v string) *UpdateBotInput {
	s.BotName = &v
	return s
}

// SetDataPrivacy sets the DataPrivacy field's value.
func (s *UpdateBotInput) SetDataPrivacy(v *DataPrivacy) *UpdateBotInput {
	s.DataPrivacy = v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateBotInput) SetDescription(v string) *UpdateBotInput {
	s.Description = &v
	return s
}

// SetIdleSessionTTLInSeconds sets the IdleSessionTTLInSeconds field's value.
func (s *UpdateBotInput) SetIdleSessionTTLInSeconds(v int64) *UpdateBotInput {
	s.IdleSessionTTLInSeconds = &v
	return s
}

// SetRoleArn sets the RoleArn field's value.
func (s *UpdateBotInput) SetRoleArn(v string) *UpdateBotInput {
	s.RoleArn = &v
	return s
}

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

	// The unique identifier of the bot that contains the locale.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that contains the locale to be updated. The version
	// can only be the DRAFT version.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The new description of the locale.
	Description *string `locationName:"description" type:"string"`

	// The identifier of the language and locale to update. The string must match
	// one of the supported locales. For more information, see Supported languages
	// (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The new confidence threshold where Amazon Lex inserts the AMAZON.FallbackIntent
	// and AMAZON.KendraSearchIntent intents in the list of possible intents for
	// an utterance.
	//
	// NluIntentConfidenceThreshold is a required field
	NluIntentConfidenceThreshold *float64 `locationName:"nluIntentConfidenceThreshold" type:"double" required:"true"`

	// The new Amazon Polly voice Amazon Lex should use for voice interaction with
	// the user.
	VoiceSettings *VoiceSettings `locationName:"voiceSettings" type:"structure"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateBotLocaleInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "UpdateBotLocaleInput"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion == nil {
		invalidParams.Add(request.NewErrParamRequired("BotVersion"))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.LocaleId == nil {
		invalidParams.Add(request.NewErrParamRequired("LocaleId"))
	}
	if s.LocaleId != nil && len(*s.LocaleId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("LocaleId", 1))
	}
	if s.NluIntentConfidenceThreshold == nil {
		invalidParams.Add(request.NewErrParamRequired("NluIntentConfidenceThreshold"))
	}
	if s.VoiceSettings != nil {
		if err := s.VoiceSettings.Validate(); err != nil {
			invalidParams.AddNested("VoiceSettings", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *UpdateBotLocaleInput) SetBotId(v string) *UpdateBotLocaleInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateBotLocaleInput) SetBotVersion(v string) *UpdateBotLocaleInput {
	s.BotVersion = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateBotLocaleInput) SetDescription(v string) *UpdateBotLocaleInput {
	s.Description = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *UpdateBotLocaleInput) SetLocaleId(v string) *UpdateBotLocaleInput {
	s.LocaleId = &v
	return s
}

// SetNluIntentConfidenceThreshold sets the NluIntentConfidenceThreshold field's value.
func (s *UpdateBotLocaleInput) SetNluIntentConfidenceThreshold(v float64) *UpdateBotLocaleInput {
	s.NluIntentConfidenceThreshold = &v
	return s
}

// SetVoiceSettings sets the VoiceSettings field's value.
func (s *UpdateBotLocaleInput) SetVoiceSettings(v *VoiceSettings) *UpdateBotLocaleInput {
	s.VoiceSettings = v
	return s
}

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

	// The identifier of the bot that contains the updated locale.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The current status of the locale. When the bot status is Built the locale
	// is ready for use.
	BotLocaleStatus *string `locationName:"botLocaleStatus" type:"string" enum:"BotLocaleStatus"`

	// The version of the bot that contains the updated locale.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// A timestamp of the date and time that the locale was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The updated description of the locale.
	Description *string `locationName:"description" type:"string"`

	// If the botLocaleStatus is Failed, the failureReasons field lists the errors
	// that occurred while building the bot.
	FailureReasons []*string `locationName:"failureReasons" type:"list"`

	// A timestamp of the date and time that the locale was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The language and locale of the updated bot locale.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The updated locale name for the locale.
	LocaleName *string `locationName:"localeName" type:"string"`

	// The updated confidence threshold for inserting the AMAZON.FallbackIntent
	// and AMAZON.KendraSearchIntent intents in the list of possible intents for
	// an utterance.
	NluIntentConfidenceThreshold *float64 `locationName:"nluIntentConfidenceThreshold" type:"double"`

	// The updated Amazon Polly voice to use for voice interaction with the user.
	VoiceSettings *VoiceSettings `locationName:"voiceSettings" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *UpdateBotLocaleOutput) SetBotId(v string) *UpdateBotLocaleOutput {
	s.BotId = &v
	return s
}

// SetBotLocaleStatus sets the BotLocaleStatus field's value.
func (s *UpdateBotLocaleOutput) SetBotLocaleStatus(v string) *UpdateBotLocaleOutput {
	s.BotLocaleStatus = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateBotLocaleOutput) SetBotVersion(v string) *UpdateBotLocaleOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *UpdateBotLocaleOutput) SetCreationDateTime(v time.Time) *UpdateBotLocaleOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateBotLocaleOutput) SetDescription(v string) *UpdateBotLocaleOutput {
	s.Description = &v
	return s
}

// SetFailureReasons sets the FailureReasons field's value.
func (s *UpdateBotLocaleOutput) SetFailureReasons(v []*string) *UpdateBotLocaleOutput {
	s.FailureReasons = v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *UpdateBotLocaleOutput) SetLastUpdatedDateTime(v time.Time) *UpdateBotLocaleOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *UpdateBotLocaleOutput) SetLocaleId(v string) *UpdateBotLocaleOutput {
	s.LocaleId = &v
	return s
}

// SetLocaleName sets the LocaleName field's value.
func (s *UpdateBotLocaleOutput) SetLocaleName(v string) *UpdateBotLocaleOutput {
	s.LocaleName = &v
	return s
}

// SetNluIntentConfidenceThreshold sets the NluIntentConfidenceThreshold field's value.
func (s *UpdateBotLocaleOutput) SetNluIntentConfidenceThreshold(v float64) *UpdateBotLocaleOutput {
	s.NluIntentConfidenceThreshold = &v
	return s
}

// SetVoiceSettings sets the VoiceSettings field's value.
func (s *UpdateBotLocaleOutput) SetVoiceSettings(v *VoiceSettings) *UpdateBotLocaleOutput {
	s.VoiceSettings = v
	return s
}

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

	// The unique identifier of the bot that was updated.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The name of the bot after the update.
	BotName *string `locationName:"botName" min:"1" type:"string"`

	// Shows the current status of the bot. The bot is first in the Creating status.
	// Once the bot is read for use, it changes to the Available status. After the
	// bot is created, you can use the DRAFT version of the bot.
	BotStatus *string `locationName:"botStatus" type:"string" enum:"BotStatus"`

	// A timestamp of the date and time that the bot was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The data privacy settings for the bot after the update.
	DataPrivacy *DataPrivacy `locationName:"dataPrivacy" type:"structure"`

	// The description of the bot after the update.
	Description *string `locationName:"description" type:"string"`

	// The session timeout, in seconds, for the bot after the update.
	IdleSessionTTLInSeconds *int64 `locationName:"idleSessionTTLInSeconds" min:"60" type:"integer"`

	// A timestamp of the date and time that the bot was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The Amazon Resource Name (ARN) of the IAM role used by the bot after the
	// update.
	RoleArn *string `locationName:"roleArn" min:"32" type:"string"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *UpdateBotOutput) SetBotId(v string) *UpdateBotOutput {
	s.BotId = &v
	return s
}

// SetBotName sets the BotName field's value.
func (s *UpdateBotOutput) SetBotName(v string) *UpdateBotOutput {
	s.BotName = &v
	return s
}

// SetBotStatus sets the BotStatus field's value.
func (s *UpdateBotOutput) SetBotStatus(v string) *UpdateBotOutput {
	s.BotStatus = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *UpdateBotOutput) SetCreationDateTime(v time.Time) *UpdateBotOutput {
	s.CreationDateTime = &v
	return s
}

// SetDataPrivacy sets the DataPrivacy field's value.
func (s *UpdateBotOutput) SetDataPrivacy(v *DataPrivacy) *UpdateBotOutput {
	s.DataPrivacy = v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateBotOutput) SetDescription(v string) *UpdateBotOutput {
	s.Description = &v
	return s
}

// SetIdleSessionTTLInSeconds sets the IdleSessionTTLInSeconds field's value.
func (s *UpdateBotOutput) SetIdleSessionTTLInSeconds(v int64) *UpdateBotOutput {
	s.IdleSessionTTLInSeconds = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *UpdateBotOutput) SetLastUpdatedDateTime(v time.Time) *UpdateBotOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetRoleArn sets the RoleArn field's value.
func (s *UpdateBotOutput) SetRoleArn(v string) *UpdateBotOutput {
	s.RoleArn = &v
	return s
}

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

	// The unique identifier Amazon Lex assigned to the export.
	//
	// ExportId is a required field
	ExportId *string `location:"uri" locationName:"exportId" min:"10" type:"string" required:"true"`

	// The new password to use to encrypt the export zip archive.
	FilePassword *string `locationName:"filePassword" min:"1" type:"string" sensitive:"true"`
}

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

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

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

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

// SetExportId sets the ExportId field's value.
func (s *UpdateExportInput) SetExportId(v string) *UpdateExportInput {
	s.ExportId = &v
	return s
}

// SetFilePassword sets the FilePassword field's value.
func (s *UpdateExportInput) SetFilePassword(v string) *UpdateExportInput {
	s.FilePassword = &v
	return s
}

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

	// The date and time that the export was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The unique identifier Amazon Lex assigned to the export.
	ExportId *string `locationName:"exportId" min:"10" type:"string"`

	// The status of the export. When the status is Completed the export archive
	// is available for download.
	ExportStatus *string `locationName:"exportStatus" type:"string" enum:"ExportStatus"`

	// The file format used for the files that define the resource.
	FileFormat *string `locationName:"fileFormat" type:"string" enum:"ImportExportFileFormat"`

	// The date and time that the export was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// A description of the type of resource that was exported, either a bot or
	// a bot locale.
	ResourceSpecification *ExportResourceSpecification `locationName:"resourceSpecification" type:"structure"`
}

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

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

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *UpdateExportOutput) SetCreationDateTime(v time.Time) *UpdateExportOutput {
	s.CreationDateTime = &v
	return s
}

// SetExportId sets the ExportId field's value.
func (s *UpdateExportOutput) SetExportId(v string) *UpdateExportOutput {
	s.ExportId = &v
	return s
}

// SetExportStatus sets the ExportStatus field's value.
func (s *UpdateExportOutput) SetExportStatus(v string) *UpdateExportOutput {
	s.ExportStatus = &v
	return s
}

// SetFileFormat sets the FileFormat field's value.
func (s *UpdateExportOutput) SetFileFormat(v string) *UpdateExportOutput {
	s.FileFormat = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *UpdateExportOutput) SetLastUpdatedDateTime(v time.Time) *UpdateExportOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetResourceSpecification sets the ResourceSpecification field's value.
func (s *UpdateExportOutput) SetResourceSpecification(v *ExportResourceSpecification) *UpdateExportOutput {
	s.ResourceSpecification = v
	return s
}

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

	// The identifier of the bot that contains the intent.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that contains the intent. Must be DRAFT.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The new description of the intent.
	Description *string `locationName:"description" type:"string"`

	// The new Lambda function to use between each turn of the conversation with
	// the bot.
	DialogCodeHook *DialogCodeHookSettings `locationName:"dialogCodeHook" type:"structure"`

	// The new Lambda function to call when all of the intents required slots are
	// provided and the intent is ready for fulfillment.
	FulfillmentCodeHook *FulfillmentCodeHookSettings `locationName:"fulfillmentCodeHook" type:"structure"`

	// A new list of contexts that must be active in order for Amazon Lex to consider
	// the intent.
	InputContexts []*InputContext `locationName:"inputContexts" type:"list"`

	// The new response that Amazon Lex sends the user when the intent is closed.
	IntentClosingSetting *IntentClosingSetting `locationName:"intentClosingSetting" type:"structure"`

	// New prompts that Amazon Lex sends to the user to confirm the completion of
	// an intent.
	IntentConfirmationSetting *IntentConfirmationSetting `locationName:"intentConfirmationSetting" type:"structure"`

	// The unique identifier of the intent to update.
	//
	// IntentId is a required field
	IntentId *string `location:"uri" locationName:"intentId" min:"10" type:"string" required:"true"`

	// The new name for the intent.
	//
	// IntentName is a required field
	IntentName *string `locationName:"intentName" min:"1" type:"string" required:"true"`

	// New configuration settings for connecting to an Amazon Kendra index.
	KendraConfiguration *KendraConfiguration `locationName:"kendraConfiguration" type:"structure"`

	// The identifier of the language and locale where this intent is used. The
	// string must match one of the supported locales. For more information, see
	// Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// A new list of contexts that Amazon Lex activates when the intent is fulfilled.
	OutputContexts []*OutputContext `locationName:"outputContexts" type:"list"`

	// The signature of the new built-in intent to use as the parent of this intent.
	ParentIntentSignature *string `locationName:"parentIntentSignature" type:"string"`

	// New utterances used to invoke the intent.
	SampleUtterances []*SampleUtterance `locationName:"sampleUtterances" type:"list"`

	// A new list of slots and their priorities that are contained by the intent.
	SlotPriorities []*SlotPriority `locationName:"slotPriorities" type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateIntentInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "UpdateIntentInput"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion == nil {
		invalidParams.Add(request.NewErrParamRequired("BotVersion"))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.IntentId == nil {
		invalidParams.Add(request.NewErrParamRequired("IntentId"))
	}
	if s.IntentId != nil && len(*s.IntentId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("IntentId", 10))
	}
	if s.IntentName == nil {
		invalidParams.Add(request.NewErrParamRequired("IntentName"))
	}
	if s.IntentName != nil && len(*s.IntentName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("IntentName", 1))
	}
	if s.LocaleId == nil {
		invalidParams.Add(request.NewErrParamRequired("LocaleId"))
	}
	if s.LocaleId != nil && len(*s.LocaleId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("LocaleId", 1))
	}
	if s.DialogCodeHook != nil {
		if err := s.DialogCodeHook.Validate(); err != nil {
			invalidParams.AddNested("DialogCodeHook", err.(request.ErrInvalidParams))
		}
	}
	if s.FulfillmentCodeHook != nil {
		if err := s.FulfillmentCodeHook.Validate(); err != nil {
			invalidParams.AddNested("FulfillmentCodeHook", err.(request.ErrInvalidParams))
		}
	}
	if s.InputContexts != nil {
		for i, v := range s.InputContexts {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "InputContexts", i), err.(request.ErrInvalidParams))
			}
		}
	}
	if s.IntentClosingSetting != nil {
		if err := s.IntentClosingSetting.Validate(); err != nil {
			invalidParams.AddNested("IntentClosingSetting", err.(request.ErrInvalidParams))
		}
	}
	if s.IntentConfirmationSetting != nil {
		if err := s.IntentConfirmationSetting.Validate(); err != nil {
			invalidParams.AddNested("IntentConfirmationSetting", err.(request.ErrInvalidParams))
		}
	}
	if s.KendraConfiguration != nil {
		if err := s.KendraConfiguration.Validate(); err != nil {
			invalidParams.AddNested("KendraConfiguration", err.(request.ErrInvalidParams))
		}
	}
	if s.OutputContexts != nil {
		for i, v := range s.OutputContexts {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "OutputContexts", i), err.(request.ErrInvalidParams))
			}
		}
	}
	if s.SampleUtterances != nil {
		for i, v := range s.SampleUtterances {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SampleUtterances", i), err.(request.ErrInvalidParams))
			}
		}
	}
	if s.SlotPriorities != nil {
		for i, v := range s.SlotPriorities {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SlotPriorities", i), err.(request.ErrInvalidParams))
			}
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *UpdateIntentInput) SetBotId(v string) *UpdateIntentInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateIntentInput) SetBotVersion(v string) *UpdateIntentInput {
	s.BotVersion = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateIntentInput) SetDescription(v string) *UpdateIntentInput {
	s.Description = &v
	return s
}

// SetDialogCodeHook sets the DialogCodeHook field's value.
func (s *UpdateIntentInput) SetDialogCodeHook(v *DialogCodeHookSettings) *UpdateIntentInput {
	s.DialogCodeHook = v
	return s
}

// SetFulfillmentCodeHook sets the FulfillmentCodeHook field's value.
func (s *UpdateIntentInput) SetFulfillmentCodeHook(v *FulfillmentCodeHookSettings) *UpdateIntentInput {
	s.FulfillmentCodeHook = v
	return s
}

// SetInputContexts sets the InputContexts field's value.
func (s *UpdateIntentInput) SetInputContexts(v []*InputContext) *UpdateIntentInput {
	s.InputContexts = v
	return s
}

// SetIntentClosingSetting sets the IntentClosingSetting field's value.
func (s *UpdateIntentInput) SetIntentClosingSetting(v *IntentClosingSetting) *UpdateIntentInput {
	s.IntentClosingSetting = v
	return s
}

// SetIntentConfirmationSetting sets the IntentConfirmationSetting field's value.
func (s *UpdateIntentInput) SetIntentConfirmationSetting(v *IntentConfirmationSetting) *UpdateIntentInput {
	s.IntentConfirmationSetting = v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *UpdateIntentInput) SetIntentId(v string) *UpdateIntentInput {
	s.IntentId = &v
	return s
}

// SetIntentName sets the IntentName field's value.
func (s *UpdateIntentInput) SetIntentName(v string) *UpdateIntentInput {
	s.IntentName = &v
	return s
}

// SetKendraConfiguration sets the KendraConfiguration field's value.
func (s *UpdateIntentInput) SetKendraConfiguration(v *KendraConfiguration) *UpdateIntentInput {
	s.KendraConfiguration = v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *UpdateIntentInput) SetLocaleId(v string) *UpdateIntentInput {
	s.LocaleId = &v
	return s
}

// SetOutputContexts sets the OutputContexts field's value.
func (s *UpdateIntentInput) SetOutputContexts(v []*OutputContext) *UpdateIntentInput {
	s.OutputContexts = v
	return s
}

// SetParentIntentSignature sets the ParentIntentSignature field's value.
func (s *UpdateIntentInput) SetParentIntentSignature(v string) *UpdateIntentInput {
	s.ParentIntentSignature = &v
	return s
}

// SetSampleUtterances sets the SampleUtterances field's value.
func (s *UpdateIntentInput) SetSampleUtterances(v []*SampleUtterance) *UpdateIntentInput {
	s.SampleUtterances = v
	return s
}

// SetSlotPriorities sets the SlotPriorities field's value.
func (s *UpdateIntentInput) SetSlotPriorities(v []*SlotPriority) *UpdateIntentInput {
	s.SlotPriorities = v
	return s
}

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

	// The identifier of the bot that contains the intent.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot that contains the intent. Will always be DRAFT.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// A timestamp of when the intent was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The updated description of the intent.
	Description *string `locationName:"description" type:"string"`

	// The updated Lambda function called during each turn of the conversation with
	// the user.
	DialogCodeHook *DialogCodeHookSettings `locationName:"dialogCodeHook" type:"structure"`

	// The updated Lambda function called when the intent is ready for fulfillment.
	FulfillmentCodeHook *FulfillmentCodeHookSettings `locationName:"fulfillmentCodeHook" type:"structure"`

	// The updated list of contexts that must be active for the intent to be considered
	// by Amazon Lex.
	InputContexts []*InputContext `locationName:"inputContexts" type:"list"`

	// The updated response that Amazon Lex sends the user when the intent is closed.
	IntentClosingSetting *IntentClosingSetting `locationName:"intentClosingSetting" type:"structure"`

	// The updated prompts that Amazon Lex sends to the user to confirm the completion
	// of an intent.
	IntentConfirmationSetting *IntentConfirmationSetting `locationName:"intentConfirmationSetting" type:"structure"`

	// The identifier of the intent that was updated.
	IntentId *string `locationName:"intentId" min:"10" type:"string"`

	// The updated name of the intent.
	IntentName *string `locationName:"intentName" min:"1" type:"string"`

	// The updated configuration for connecting to an Amazon Kendra index with the
	// AMAZON.KendraSearchIntent intent.
	KendraConfiguration *KendraConfiguration `locationName:"kendraConfiguration" type:"structure"`

	// A timestamp of the last time that the intent was modified.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The updated language and locale of the intent.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The updated list of contexts that Amazon Lex activates when the intent is
	// fulfilled.
	OutputContexts []*OutputContext `locationName:"outputContexts" type:"list"`

	// The updated built-in intent that is the parent of this intent.
	ParentIntentSignature *string `locationName:"parentIntentSignature" type:"string"`

	// The updated list of sample utterances for the intent.
	SampleUtterances []*SampleUtterance `locationName:"sampleUtterances" type:"list"`

	// The updated list of slots and their priorities that are elicited from the
	// user for the intent.
	SlotPriorities []*SlotPriority `locationName:"slotPriorities" type:"list"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *UpdateIntentOutput) SetBotId(v string) *UpdateIntentOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateIntentOutput) SetBotVersion(v string) *UpdateIntentOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *UpdateIntentOutput) SetCreationDateTime(v time.Time) *UpdateIntentOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateIntentOutput) SetDescription(v string) *UpdateIntentOutput {
	s.Description = &v
	return s
}

// SetDialogCodeHook sets the DialogCodeHook field's value.
func (s *UpdateIntentOutput) SetDialogCodeHook(v *DialogCodeHookSettings) *UpdateIntentOutput {
	s.DialogCodeHook = v
	return s
}

// SetFulfillmentCodeHook sets the FulfillmentCodeHook field's value.
func (s *UpdateIntentOutput) SetFulfillmentCodeHook(v *FulfillmentCodeHookSettings) *UpdateIntentOutput {
	s.FulfillmentCodeHook = v
	return s
}

// SetInputContexts sets the InputContexts field's value.
func (s *UpdateIntentOutput) SetInputContexts(v []*InputContext) *UpdateIntentOutput {
	s.InputContexts = v
	return s
}

// SetIntentClosingSetting sets the IntentClosingSetting field's value.
func (s *UpdateIntentOutput) SetIntentClosingSetting(v *IntentClosingSetting) *UpdateIntentOutput {
	s.IntentClosingSetting = v
	return s
}

// SetIntentConfirmationSetting sets the IntentConfirmationSetting field's value.
func (s *UpdateIntentOutput) SetIntentConfirmationSetting(v *IntentConfirmationSetting) *UpdateIntentOutput {
	s.IntentConfirmationSetting = v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *UpdateIntentOutput) SetIntentId(v string) *UpdateIntentOutput {
	s.IntentId = &v
	return s
}

// SetIntentName sets the IntentName field's value.
func (s *UpdateIntentOutput) SetIntentName(v string) *UpdateIntentOutput {
	s.IntentName = &v
	return s
}

// SetKendraConfiguration sets the KendraConfiguration field's value.
func (s *UpdateIntentOutput) SetKendraConfiguration(v *KendraConfiguration) *UpdateIntentOutput {
	s.KendraConfiguration = v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *UpdateIntentOutput) SetLastUpdatedDateTime(v time.Time) *UpdateIntentOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *UpdateIntentOutput) SetLocaleId(v string) *UpdateIntentOutput {
	s.LocaleId = &v
	return s
}

// SetOutputContexts sets the OutputContexts field's value.
func (s *UpdateIntentOutput) SetOutputContexts(v []*OutputContext) *UpdateIntentOutput {
	s.OutputContexts = v
	return s
}

// SetParentIntentSignature sets the ParentIntentSignature field's value.
func (s *UpdateIntentOutput) SetParentIntentSignature(v string) *UpdateIntentOutput {
	s.ParentIntentSignature = &v
	return s
}

// SetSampleUtterances sets the SampleUtterances field's value.
func (s *UpdateIntentOutput) SetSampleUtterances(v []*SampleUtterance) *UpdateIntentOutput {
	s.SampleUtterances = v
	return s
}

// SetSlotPriorities sets the SlotPriorities field's value.
func (s *UpdateIntentOutput) SetSlotPriorities(v []*SlotPriority) *UpdateIntentOutput {
	s.SlotPriorities = v
	return s
}

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

	// The identifier of the revision of the policy to update. If this revision
	// ID doesn't match the current revision ID, Amazon Lex throws an exception.
	//
	// If you don't specify a revision, Amazon Lex overwrites the contents of the
	// policy with the new values.
	ExpectedRevisionId *string `location:"querystring" locationName:"expectedRevisionId" min:"1" type:"string"`

	// A resource policy to add to the resource. The policy is a JSON structure
	// that contains one or more statements that define the policy. The policy must
	// follow the IAM syntax. For more information about the contents of a JSON
	// policy document, see IAM JSON policy reference (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html).
	//
	// If the policy isn't valid, Amazon Lex returns a validation exception.
	//
	// Policy is a required field
	Policy *string `locationName:"policy" min:"2" type:"string" required:"true"`

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy is attached to.
	//
	// ResourceArn is a required field
	ResourceArn *string `location:"uri" locationName:"resourceArn" min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetExpectedRevisionId sets the ExpectedRevisionId field's value.
func (s *UpdateResourcePolicyInput) SetExpectedRevisionId(v string) *UpdateResourcePolicyInput {
	s.ExpectedRevisionId = &v
	return s
}

// SetPolicy sets the Policy field's value.
func (s *UpdateResourcePolicyInput) SetPolicy(v string) *UpdateResourcePolicyInput {
	s.Policy = &v
	return s
}

// SetResourceArn sets the ResourceArn field's value.
func (s *UpdateResourcePolicyInput) SetResourceArn(v string) *UpdateResourcePolicyInput {
	s.ResourceArn = &v
	return s
}

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

	// The Amazon Resource Name (ARN) of the bot or bot alias that the resource
	// policy is attached to.
	ResourceArn *string `locationName:"resourceArn" min:"1" type:"string"`

	// The current revision of the resource policy. Use the revision ID to make
	// sure that you are updating the most current version of a resource policy
	// when you add a policy statement to a resource, delete a resource, or update
	// a resource.
	RevisionId *string `locationName:"revisionId" min:"1" type:"string"`
}

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

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

// SetResourceArn sets the ResourceArn field's value.
func (s *UpdateResourcePolicyOutput) SetResourceArn(v string) *UpdateResourcePolicyOutput {
	s.ResourceArn = &v
	return s
}

// SetRevisionId sets the RevisionId field's value.
func (s *UpdateResourcePolicyOutput) SetRevisionId(v string) *UpdateResourcePolicyOutput {
	s.RevisionId = &v
	return s
}

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

	// The unique identifier of the bot that contains the slot.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that contains the slot. Must always be DRAFT.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The new description for the slot.
	Description *string `locationName:"description" type:"string"`

	// The identifier of the intent that contains the slot.
	//
	// IntentId is a required field
	IntentId *string `location:"uri" locationName:"intentId" min:"10" type:"string" required:"true"`

	// The identifier of the language and locale that contains the slot. The string
	// must match one of the supported locales. For more information, see Supported
	// languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// Determines whether the slot accepts multiple values in one response. Multiple
	// value slots are only available in the en-US locale. If you set this value
	// to true in any other locale, Amazon Lex throws a ValidationException.
	//
	// If the multipleValuesSetting is not set, the default value is false.
	MultipleValuesSetting *MultipleValuesSetting `locationName:"multipleValuesSetting" type:"structure"`

	// New settings that determine how slot values are formatted in Amazon CloudWatch
	// logs.
	ObfuscationSetting *ObfuscationSetting `locationName:"obfuscationSetting" type:"structure"`

	// The unique identifier for the slot to update.
	//
	// SlotId is a required field
	SlotId *string `location:"uri" locationName:"slotId" min:"10" type:"string" required:"true"`

	// The new name for the slot.
	//
	// SlotName is a required field
	SlotName *string `locationName:"slotName" min:"1" type:"string" required:"true"`

	// The unique identifier of the new slot type to associate with this slot.
	//
	// SlotTypeId is a required field
	SlotTypeId *string `locationName:"slotTypeId" min:"1" type:"string" required:"true"`

	// A new set of prompts that Amazon Lex sends to the user to elicit a response
	// the provides a value for the slot.
	//
	// ValueElicitationSetting is a required field
	ValueElicitationSetting *SlotValueElicitationSetting `locationName:"valueElicitationSetting" type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateSlotInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "UpdateSlotInput"}
	if s.BotId == nil {
		invalidParams.Add(request.NewErrParamRequired("BotId"))
	}
	if s.BotId != nil && len(*s.BotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("BotId", 10))
	}
	if s.BotVersion == nil {
		invalidParams.Add(request.NewErrParamRequired("BotVersion"))
	}
	if s.BotVersion != nil && len(*s.BotVersion) < 5 {
		invalidParams.Add(request.NewErrParamMinLen("BotVersion", 5))
	}
	if s.IntentId == nil {
		invalidParams.Add(request.NewErrParamRequired("IntentId"))
	}
	if s.IntentId != nil && len(*s.IntentId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("IntentId", 10))
	}
	if s.LocaleId == nil {
		invalidParams.Add(request.NewErrParamRequired("LocaleId"))
	}
	if s.LocaleId != nil && len(*s.LocaleId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("LocaleId", 1))
	}
	if s.SlotId == nil {
		invalidParams.Add(request.NewErrParamRequired("SlotId"))
	}
	if s.SlotId != nil && len(*s.SlotId) < 10 {
		invalidParams.Add(request.NewErrParamMinLen("SlotId", 10))
	}
	if s.SlotName == nil {
		invalidParams.Add(request.NewErrParamRequired("SlotName"))
	}
	if s.SlotName != nil && len(*s.SlotName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SlotName", 1))
	}
	if s.SlotTypeId == nil {
		invalidParams.Add(request.NewErrParamRequired("SlotTypeId"))
	}
	if s.SlotTypeId != nil && len(*s.SlotTypeId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("SlotTypeId", 1))
	}
	if s.ValueElicitationSetting == nil {
		invalidParams.Add(request.NewErrParamRequired("ValueElicitationSetting"))
	}
	if s.ObfuscationSetting != nil {
		if err := s.ObfuscationSetting.Validate(); err != nil {
			invalidParams.AddNested("ObfuscationSetting", err.(request.ErrInvalidParams))
		}
	}
	if s.ValueElicitationSetting != nil {
		if err := s.ValueElicitationSetting.Validate(); err != nil {
			invalidParams.AddNested("ValueElicitationSetting", err.(request.ErrInvalidParams))
		}
	}

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

// SetBotId sets the BotId field's value.
func (s *UpdateSlotInput) SetBotId(v string) *UpdateSlotInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateSlotInput) SetBotVersion(v string) *UpdateSlotInput {
	s.BotVersion = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateSlotInput) SetDescription(v string) *UpdateSlotInput {
	s.Description = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *UpdateSlotInput) SetIntentId(v string) *UpdateSlotInput {
	s.IntentId = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *UpdateSlotInput) SetLocaleId(v string) *UpdateSlotInput {
	s.LocaleId = &v
	return s
}

// SetMultipleValuesSetting sets the MultipleValuesSetting field's value.
func (s *UpdateSlotInput) SetMultipleValuesSetting(v *MultipleValuesSetting) *UpdateSlotInput {
	s.MultipleValuesSetting = v
	return s
}

// SetObfuscationSetting sets the ObfuscationSetting field's value.
func (s *UpdateSlotInput) SetObfuscationSetting(v *ObfuscationSetting) *UpdateSlotInput {
	s.ObfuscationSetting = v
	return s
}

// SetSlotId sets the SlotId field's value.
func (s *UpdateSlotInput) SetSlotId(v string) *UpdateSlotInput {
	s.SlotId = &v
	return s
}

// SetSlotName sets the SlotName field's value.
func (s *UpdateSlotInput) SetSlotName(v string) *UpdateSlotInput {
	s.SlotName = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *UpdateSlotInput) SetSlotTypeId(v string) *UpdateSlotInput {
	s.SlotTypeId = &v
	return s
}

// SetValueElicitationSetting sets the ValueElicitationSetting field's value.
func (s *UpdateSlotInput) SetValueElicitationSetting(v *SlotValueElicitationSetting) *UpdateSlotInput {
	s.ValueElicitationSetting = v
	return s
}

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

	// The identifier of the bot that contains the slot.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The identifier of the slot version that contains the slot. Will always be
	// DRAFT.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// The timestamp of the date and time that the slot was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The updated description of the bot.
	Description *string `locationName:"description" type:"string"`

	// The intent that contains the slot.
	IntentId *string `locationName:"intentId" min:"10" type:"string"`

	// The timestamp of the date and time that the slot was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The locale that contains the slot.
	LocaleId *string `locationName:"localeId" type:"string"`

	// Indicates whether the slot accepts multiple values in one response.
	MultipleValuesSetting *MultipleValuesSetting `locationName:"multipleValuesSetting" type:"structure"`

	// The updated setting that determines whether the slot value is obfuscated
	// in the Amazon CloudWatch logs.
	ObfuscationSetting *ObfuscationSetting `locationName:"obfuscationSetting" type:"structure"`

	// The unique identifier of the slot that was updated.
	SlotId *string `locationName:"slotId" min:"10" type:"string"`

	// The updated name of the slot.
	SlotName *string `locationName:"slotName" min:"1" type:"string"`

	// The updated identifier of the slot type that provides values for the slot.
	SlotTypeId *string `locationName:"slotTypeId" min:"1" type:"string"`

	// The updated prompts that Amazon Lex sends to the user to elicit a response
	// that provides a value for the slot.
	ValueElicitationSetting *SlotValueElicitationSetting `locationName:"valueElicitationSetting" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *UpdateSlotOutput) SetBotId(v string) *UpdateSlotOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateSlotOutput) SetBotVersion(v string) *UpdateSlotOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *UpdateSlotOutput) SetCreationDateTime(v time.Time) *UpdateSlotOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateSlotOutput) SetDescription(v string) *UpdateSlotOutput {
	s.Description = &v
	return s
}

// SetIntentId sets the IntentId field's value.
func (s *UpdateSlotOutput) SetIntentId(v string) *UpdateSlotOutput {
	s.IntentId = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *UpdateSlotOutput) SetLastUpdatedDateTime(v time.Time) *UpdateSlotOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *UpdateSlotOutput) SetLocaleId(v string) *UpdateSlotOutput {
	s.LocaleId = &v
	return s
}

// SetMultipleValuesSetting sets the MultipleValuesSetting field's value.
func (s *UpdateSlotOutput) SetMultipleValuesSetting(v *MultipleValuesSetting) *UpdateSlotOutput {
	s.MultipleValuesSetting = v
	return s
}

// SetObfuscationSetting sets the ObfuscationSetting field's value.
func (s *UpdateSlotOutput) SetObfuscationSetting(v *ObfuscationSetting) *UpdateSlotOutput {
	s.ObfuscationSetting = v
	return s
}

// SetSlotId sets the SlotId field's value.
func (s *UpdateSlotOutput) SetSlotId(v string) *UpdateSlotOutput {
	s.SlotId = &v
	return s
}

// SetSlotName sets the SlotName field's value.
func (s *UpdateSlotOutput) SetSlotName(v string) *UpdateSlotOutput {
	s.SlotName = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *UpdateSlotOutput) SetSlotTypeId(v string) *UpdateSlotOutput {
	s.SlotTypeId = &v
	return s
}

// SetValueElicitationSetting sets the ValueElicitationSetting field's value.
func (s *UpdateSlotOutput) SetValueElicitationSetting(v *SlotValueElicitationSetting) *UpdateSlotOutput {
	s.ValueElicitationSetting = v
	return s
}

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

	// The identifier of the bot that contains the slot type.
	//
	// BotId is a required field
	BotId *string `location:"uri" locationName:"botId" min:"10" type:"string" required:"true"`

	// The version of the bot that contains the slot type. Must be DRAFT.
	//
	// BotVersion is a required field
	BotVersion *string `location:"uri" locationName:"botVersion" min:"5" type:"string" required:"true"`

	// The new description of the slot type.
	Description *string `locationName:"description" type:"string"`

	// The identifier of the language and locale that contains the slot type. The
	// string must match one of the supported locales. For more information, see
	// Supported languages (https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html).
	//
	// LocaleId is a required field
	LocaleId *string `location:"uri" locationName:"localeId" type:"string" required:"true"`

	// The new built-in slot type that should be used as the parent of this slot
	// type.
	ParentSlotTypeSignature *string `locationName:"parentSlotTypeSignature" type:"string"`

	// The unique identifier of the slot type to update.
	//
	// SlotTypeId is a required field
	SlotTypeId *string `location:"uri" locationName:"slotTypeId" min:"10" type:"string" required:"true"`

	// The new name of the slot type.
	//
	// SlotTypeName is a required field
	SlotTypeName *string `locationName:"slotTypeName" min:"1" type:"string" required:"true"`

	// A new list of values and their optional synonyms that define the values that
	// the slot type can take.
	SlotTypeValues []*SlotTypeValue `locationName:"slotTypeValues" min:"1" type:"list"`

	// The strategy that Amazon Lex should use when deciding on a value from the
	// list of slot type values.
	//
	// ValueSelectionSetting is a required field
	ValueSelectionSetting *SlotValueSelectionSetting `locationName:"valueSelectionSetting" type:"structure" required:"true"`
}

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

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

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

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

// SetBotId sets the BotId field's value.
func (s *UpdateSlotTypeInput) SetBotId(v string) *UpdateSlotTypeInput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateSlotTypeInput) SetBotVersion(v string) *UpdateSlotTypeInput {
	s.BotVersion = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateSlotTypeInput) SetDescription(v string) *UpdateSlotTypeInput {
	s.Description = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *UpdateSlotTypeInput) SetLocaleId(v string) *UpdateSlotTypeInput {
	s.LocaleId = &v
	return s
}

// SetParentSlotTypeSignature sets the ParentSlotTypeSignature field's value.
func (s *UpdateSlotTypeInput) SetParentSlotTypeSignature(v string) *UpdateSlotTypeInput {
	s.ParentSlotTypeSignature = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *UpdateSlotTypeInput) SetSlotTypeId(v string) *UpdateSlotTypeInput {
	s.SlotTypeId = &v
	return s
}

// SetSlotTypeName sets the SlotTypeName field's value.
func (s *UpdateSlotTypeInput) SetSlotTypeName(v string) *UpdateSlotTypeInput {
	s.SlotTypeName = &v
	return s
}

// SetSlotTypeValues sets the SlotTypeValues field's value.
func (s *UpdateSlotTypeInput) SetSlotTypeValues(v []*SlotTypeValue) *UpdateSlotTypeInput {
	s.SlotTypeValues = v
	return s
}

// SetValueSelectionSetting sets the ValueSelectionSetting field's value.
func (s *UpdateSlotTypeInput) SetValueSelectionSetting(v *SlotValueSelectionSetting) *UpdateSlotTypeInput {
	s.ValueSelectionSetting = v
	return s
}

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

	// The identifier of the bot that contains the slot type.
	BotId *string `locationName:"botId" min:"10" type:"string"`

	// The version of the bot that contains the slot type. This is always DRAFT.
	BotVersion *string `locationName:"botVersion" min:"5" type:"string"`

	// The timestamp of the date and time that the slot type was created.
	CreationDateTime *time.Time `locationName:"creationDateTime" type:"timestamp"`

	// The updated description of the slot type.
	Description *string `locationName:"description" type:"string"`

	// A timestamp of the date and time that the slot type was last updated.
	LastUpdatedDateTime *time.Time `locationName:"lastUpdatedDateTime" type:"timestamp"`

	// The language and locale of the updated slot type.
	LocaleId *string `locationName:"localeId" type:"string"`

	// The updated signature of the built-in slot type that is the parent of this
	// slot type.
	ParentSlotTypeSignature *string `locationName:"parentSlotTypeSignature" type:"string"`

	// The unique identifier of the updated slot type.
	SlotTypeId *string `locationName:"slotTypeId" min:"10" type:"string"`

	// The updated name of the slot type.
	SlotTypeName *string `locationName:"slotTypeName" min:"1" type:"string"`

	// The updated values that the slot type provides.
	SlotTypeValues []*SlotTypeValue `locationName:"slotTypeValues" min:"1" type:"list"`

	// The updated strategy that Amazon Lex uses to determine which value to select
	// from the slot type.
	ValueSelectionSetting *SlotValueSelectionSetting `locationName:"valueSelectionSetting" type:"structure"`
}

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

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

// SetBotId sets the BotId field's value.
func (s *UpdateSlotTypeOutput) SetBotId(v string) *UpdateSlotTypeOutput {
	s.BotId = &v
	return s
}

// SetBotVersion sets the BotVersion field's value.
func (s *UpdateSlotTypeOutput) SetBotVersion(v string) *UpdateSlotTypeOutput {
	s.BotVersion = &v
	return s
}

// SetCreationDateTime sets the CreationDateTime field's value.
func (s *UpdateSlotTypeOutput) SetCreationDateTime(v time.Time) *UpdateSlotTypeOutput {
	s.CreationDateTime = &v
	return s
}

// SetDescription sets the Description field's value.
func (s *UpdateSlotTypeOutput) SetDescription(v string) *UpdateSlotTypeOutput {
	s.Description = &v
	return s
}

// SetLastUpdatedDateTime sets the LastUpdatedDateTime field's value.
func (s *UpdateSlotTypeOutput) SetLastUpdatedDateTime(v time.Time) *UpdateSlotTypeOutput {
	s.LastUpdatedDateTime = &v
	return s
}

// SetLocaleId sets the LocaleId field's value.
func (s *UpdateSlotTypeOutput) SetLocaleId(v string) *UpdateSlotTypeOutput {
	s.LocaleId = &v
	return s
}

// SetParentSlotTypeSignature sets the ParentSlotTypeSignature field's value.
func (s *UpdateSlotTypeOutput) SetParentSlotTypeSignature(v string) *UpdateSlotTypeOutput {
	s.ParentSlotTypeSignature = &v
	return s
}

// SetSlotTypeId sets the SlotTypeId field's value.
func (s *UpdateSlotTypeOutput) SetSlotTypeId(v string) *UpdateSlotTypeOutput {
	s.SlotTypeId = &v
	return s
}

// SetSlotTypeName sets the SlotTypeName field's value.
func (s *UpdateSlotTypeOutput) SetSlotTypeName(v string) *UpdateSlotTypeOutput {
	s.SlotTypeName = &v
	return s
}

// SetSlotTypeValues sets the SlotTypeValues field's value.
func (s *UpdateSlotTypeOutput) SetSlotTypeValues(v []*SlotTypeValue) *UpdateSlotTypeOutput {
	s.SlotTypeValues = v
	return s
}

// SetValueSelectionSetting sets the ValueSelectionSetting field's value.
func (s *UpdateSlotTypeOutput) SetValueSelectionSetting(v *SlotValueSelectionSetting) *UpdateSlotTypeOutput {
	s.ValueSelectionSetting = v
	return s
}

type ValidationException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

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

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

func newErrorValidationException(v protocol.ResponseMetadata) error {
	return &ValidationException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *ValidationException) Code() string {
	return "ValidationException"
}

// Message returns the exception's message.
func (s *ValidationException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ValidationException) OrigErr() error {
	return nil
}

func (s *ValidationException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *ValidationException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *ValidationException) RequestID() string {
	return s.RespMetadata.RequestID
}

// Defines settings for using an Amazon Polly voice to communicate with a user.
type VoiceSettings struct {
	_ struct{} `type:"structure"`

	// The identifier of the Amazon Polly voice to use.
	//
	// VoiceId is a required field
	VoiceId *string `locationName:"voiceId" type:"string" required:"true"`
}

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

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

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

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

// SetVoiceId sets the VoiceId field's value.
func (s *VoiceSettings) SetVoiceId(v string) *VoiceSettings {
	s.VoiceId = &v
	return s
}

// Specifies the prompts that Amazon Lex uses while a bot is waiting for customer
// input.
type WaitAndContinueSpecification struct {
	_ struct{} `type:"structure"`

	// The response that Amazon Lex sends to indicate that the bot is ready to continue
	// the conversation.
	//
	// ContinueResponse is a required field
	ContinueResponse *ResponseSpecification `locationName:"continueResponse" type:"structure" required:"true"`

	// A response that Amazon Lex sends periodically to the user to indicate that
	// the bot is still waiting for input from the user.
	StillWaitingResponse *StillWaitingResponseSpecification `locationName:"stillWaitingResponse" type:"structure"`

	// The response that Amazon Lex sends to indicate that the bot is waiting for
	// the conversation to continue.
	//
	// WaitingResponse is a required field
	WaitingResponse *ResponseSpecification `locationName:"waitingResponse" type:"structure" required:"true"`
}

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

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

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

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

// SetContinueResponse sets the ContinueResponse field's value.
func (s *WaitAndContinueSpecification) SetContinueResponse(v *ResponseSpecification) *WaitAndContinueSpecification {
	s.ContinueResponse = v
	return s
}

// SetStillWaitingResponse sets the StillWaitingResponse field's value.
func (s *WaitAndContinueSpecification) SetStillWaitingResponse(v *StillWaitingResponseSpecification) *WaitAndContinueSpecification {
	s.StillWaitingResponse = v
	return s
}

// SetWaitingResponse sets the WaitingResponse field's value.
func (s *WaitAndContinueSpecification) SetWaitingResponse(v *ResponseSpecification) *WaitAndContinueSpecification {
	s.WaitingResponse = v
	return s
}

const (
	// BotAliasStatusCreating is a BotAliasStatus enum value
	BotAliasStatusCreating = "Creating"

	// BotAliasStatusAvailable is a BotAliasStatus enum value
	BotAliasStatusAvailable = "Available"

	// BotAliasStatusDeleting is a BotAliasStatus enum value
	BotAliasStatusDeleting = "Deleting"

	// BotAliasStatusFailed is a BotAliasStatus enum value
	BotAliasStatusFailed = "Failed"
)

// BotAliasStatus_Values returns all elements of the BotAliasStatus enum
func BotAliasStatus_Values() []string {
	return []string{
		BotAliasStatusCreating,
		BotAliasStatusAvailable,
		BotAliasStatusDeleting,
		BotAliasStatusFailed,
	}
}

const (
	// BotFilterNameBotName is a BotFilterName enum value
	BotFilterNameBotName = "BotName"
)

// BotFilterName_Values returns all elements of the BotFilterName enum
func BotFilterName_Values() []string {
	return []string{
		BotFilterNameBotName,
	}
}

const (
	// BotFilterOperatorCo is a BotFilterOperator enum value
	BotFilterOperatorCo = "CO"

	// BotFilterOperatorEq is a BotFilterOperator enum value
	BotFilterOperatorEq = "EQ"
)

// BotFilterOperator_Values returns all elements of the BotFilterOperator enum
func BotFilterOperator_Values() []string {
	return []string{
		BotFilterOperatorCo,
		BotFilterOperatorEq,
	}
}

const (
	// BotLocaleFilterNameBotLocaleName is a BotLocaleFilterName enum value
	BotLocaleFilterNameBotLocaleName = "BotLocaleName"
)

// BotLocaleFilterName_Values returns all elements of the BotLocaleFilterName enum
func BotLocaleFilterName_Values() []string {
	return []string{
		BotLocaleFilterNameBotLocaleName,
	}
}

const (
	// BotLocaleFilterOperatorCo is a BotLocaleFilterOperator enum value
	BotLocaleFilterOperatorCo = "CO"

	// BotLocaleFilterOperatorEq is a BotLocaleFilterOperator enum value
	BotLocaleFilterOperatorEq = "EQ"
)

// BotLocaleFilterOperator_Values returns all elements of the BotLocaleFilterOperator enum
func BotLocaleFilterOperator_Values() []string {
	return []string{
		BotLocaleFilterOperatorCo,
		BotLocaleFilterOperatorEq,
	}
}

const (
	// BotLocaleSortAttributeBotLocaleName is a BotLocaleSortAttribute enum value
	BotLocaleSortAttributeBotLocaleName = "BotLocaleName"
)

// BotLocaleSortAttribute_Values returns all elements of the BotLocaleSortAttribute enum
func BotLocaleSortAttribute_Values() []string {
	return []string{
		BotLocaleSortAttributeBotLocaleName,
	}
}

const (
	// BotLocaleStatusCreating is a BotLocaleStatus enum value
	BotLocaleStatusCreating = "Creating"

	// BotLocaleStatusBuilding is a BotLocaleStatus enum value
	BotLocaleStatusBuilding = "Building"

	// BotLocaleStatusBuilt is a BotLocaleStatus enum value
	BotLocaleStatusBuilt = "Built"

	// BotLocaleStatusReadyExpressTesting is a BotLocaleStatus enum value
	BotLocaleStatusReadyExpressTesting = "ReadyExpressTesting"

	// BotLocaleStatusFailed is a BotLocaleStatus enum value
	BotLocaleStatusFailed = "Failed"

	// BotLocaleStatusDeleting is a BotLocaleStatus enum value
	BotLocaleStatusDeleting = "Deleting"

	// BotLocaleStatusNotBuilt is a BotLocaleStatus enum value
	BotLocaleStatusNotBuilt = "NotBuilt"

	// BotLocaleStatusImporting is a BotLocaleStatus enum value
	BotLocaleStatusImporting = "Importing"
)

// BotLocaleStatus_Values returns all elements of the BotLocaleStatus enum
func BotLocaleStatus_Values() []string {
	return []string{
		BotLocaleStatusCreating,
		BotLocaleStatusBuilding,
		BotLocaleStatusBuilt,
		BotLocaleStatusReadyExpressTesting,
		BotLocaleStatusFailed,
		BotLocaleStatusDeleting,
		BotLocaleStatusNotBuilt,
		BotLocaleStatusImporting,
	}
}

const (
	// BotSortAttributeBotName is a BotSortAttribute enum value
	BotSortAttributeBotName = "BotName"
)

// BotSortAttribute_Values returns all elements of the BotSortAttribute enum
func BotSortAttribute_Values() []string {
	return []string{
		BotSortAttributeBotName,
	}
}

const (
	// BotStatusCreating is a BotStatus enum value
	BotStatusCreating = "Creating"

	// BotStatusAvailable is a BotStatus enum value
	BotStatusAvailable = "Available"

	// BotStatusInactive is a BotStatus enum value
	BotStatusInactive = "Inactive"

	// BotStatusDeleting is a BotStatus enum value
	BotStatusDeleting = "Deleting"

	// BotStatusFailed is a BotStatus enum value
	BotStatusFailed = "Failed"

	// BotStatusVersioning is a BotStatus enum value
	BotStatusVersioning = "Versioning"

	// BotStatusImporting is a BotStatus enum value
	BotStatusImporting = "Importing"
)

// BotStatus_Values returns all elements of the BotStatus enum
func BotStatus_Values() []string {
	return []string{
		BotStatusCreating,
		BotStatusAvailable,
		BotStatusInactive,
		BotStatusDeleting,
		BotStatusFailed,
		BotStatusVersioning,
		BotStatusImporting,
	}
}

const (
	// BotVersionSortAttributeBotVersion is a BotVersionSortAttribute enum value
	BotVersionSortAttributeBotVersion = "BotVersion"
)

// BotVersionSortAttribute_Values returns all elements of the BotVersionSortAttribute enum
func BotVersionSortAttribute_Values() []string {
	return []string{
		BotVersionSortAttributeBotVersion,
	}
}

const (
	// BuiltInIntentSortAttributeIntentSignature is a BuiltInIntentSortAttribute enum value
	BuiltInIntentSortAttributeIntentSignature = "IntentSignature"
)

// BuiltInIntentSortAttribute_Values returns all elements of the BuiltInIntentSortAttribute enum
func BuiltInIntentSortAttribute_Values() []string {
	return []string{
		BuiltInIntentSortAttributeIntentSignature,
	}
}

const (
	// BuiltInSlotTypeSortAttributeSlotTypeSignature is a BuiltInSlotTypeSortAttribute enum value
	BuiltInSlotTypeSortAttributeSlotTypeSignature = "SlotTypeSignature"
)

// BuiltInSlotTypeSortAttribute_Values returns all elements of the BuiltInSlotTypeSortAttribute enum
func BuiltInSlotTypeSortAttribute_Values() []string {
	return []string{
		BuiltInSlotTypeSortAttributeSlotTypeSignature,
	}
}

const (
	// EffectAllow is a Effect enum value
	EffectAllow = "Allow"

	// EffectDeny is a Effect enum value
	EffectDeny = "Deny"
)

// Effect_Values returns all elements of the Effect enum
func Effect_Values() []string {
	return []string{
		EffectAllow,
		EffectDeny,
	}
}

const (
	// ExportFilterNameExportResourceType is a ExportFilterName enum value
	ExportFilterNameExportResourceType = "ExportResourceType"
)

// ExportFilterName_Values returns all elements of the ExportFilterName enum
func ExportFilterName_Values() []string {
	return []string{
		ExportFilterNameExportResourceType,
	}
}

const (
	// ExportFilterOperatorCo is a ExportFilterOperator enum value
	ExportFilterOperatorCo = "CO"

	// ExportFilterOperatorEq is a ExportFilterOperator enum value
	ExportFilterOperatorEq = "EQ"
)

// ExportFilterOperator_Values returns all elements of the ExportFilterOperator enum
func ExportFilterOperator_Values() []string {
	return []string{
		ExportFilterOperatorCo,
		ExportFilterOperatorEq,
	}
}

const (
	// ExportSortAttributeLastUpdatedDateTime is a ExportSortAttribute enum value
	ExportSortAttributeLastUpdatedDateTime = "LastUpdatedDateTime"
)

// ExportSortAttribute_Values returns all elements of the ExportSortAttribute enum
func ExportSortAttribute_Values() []string {
	return []string{
		ExportSortAttributeLastUpdatedDateTime,
	}
}

const (
	// ExportStatusInProgress is a ExportStatus enum value
	ExportStatusInProgress = "InProgress"

	// ExportStatusCompleted is a ExportStatus enum value
	ExportStatusCompleted = "Completed"

	// ExportStatusFailed is a ExportStatus enum value
	ExportStatusFailed = "Failed"

	// ExportStatusDeleting is a ExportStatus enum value
	ExportStatusDeleting = "Deleting"
)

// ExportStatus_Values returns all elements of the ExportStatus enum
func ExportStatus_Values() []string {
	return []string{
		ExportStatusInProgress,
		ExportStatusCompleted,
		ExportStatusFailed,
		ExportStatusDeleting,
	}
}

const (
	// ImportExportFileFormatLexJson is a ImportExportFileFormat enum value
	ImportExportFileFormatLexJson = "LexJson"
)

// ImportExportFileFormat_Values returns all elements of the ImportExportFileFormat enum
func ImportExportFileFormat_Values() []string {
	return []string{
		ImportExportFileFormatLexJson,
	}
}

const (
	// ImportFilterNameImportResourceType is a ImportFilterName enum value
	ImportFilterNameImportResourceType = "ImportResourceType"
)

// ImportFilterName_Values returns all elements of the ImportFilterName enum
func ImportFilterName_Values() []string {
	return []string{
		ImportFilterNameImportResourceType,
	}
}

const (
	// ImportFilterOperatorCo is a ImportFilterOperator enum value
	ImportFilterOperatorCo = "CO"

	// ImportFilterOperatorEq is a ImportFilterOperator enum value
	ImportFilterOperatorEq = "EQ"
)

// ImportFilterOperator_Values returns all elements of the ImportFilterOperator enum
func ImportFilterOperator_Values() []string {
	return []string{
		ImportFilterOperatorCo,
		ImportFilterOperatorEq,
	}
}

const (
	// ImportSortAttributeLastUpdatedDateTime is a ImportSortAttribute enum value
	ImportSortAttributeLastUpdatedDateTime = "LastUpdatedDateTime"
)

// ImportSortAttribute_Values returns all elements of the ImportSortAttribute enum
func ImportSortAttribute_Values() []string {
	return []string{
		ImportSortAttributeLastUpdatedDateTime,
	}
}

const (
	// ImportStatusInProgress is a ImportStatus enum value
	ImportStatusInProgress = "InProgress"

	// ImportStatusCompleted is a ImportStatus enum value
	ImportStatusCompleted = "Completed"

	// ImportStatusFailed is a ImportStatus enum value
	ImportStatusFailed = "Failed"

	// ImportStatusDeleting is a ImportStatus enum value
	ImportStatusDeleting = "Deleting"
)

// ImportStatus_Values returns all elements of the ImportStatus enum
func ImportStatus_Values() []string {
	return []string{
		ImportStatusInProgress,
		ImportStatusCompleted,
		ImportStatusFailed,
		ImportStatusDeleting,
	}
}

const (
	// IntentFilterNameIntentName is a IntentFilterName enum value
	IntentFilterNameIntentName = "IntentName"
)

// IntentFilterName_Values returns all elements of the IntentFilterName enum
func IntentFilterName_Values() []string {
	return []string{
		IntentFilterNameIntentName,
	}
}

const (
	// IntentFilterOperatorCo is a IntentFilterOperator enum value
	IntentFilterOperatorCo = "CO"

	// IntentFilterOperatorEq is a IntentFilterOperator enum value
	IntentFilterOperatorEq = "EQ"
)

// IntentFilterOperator_Values returns all elements of the IntentFilterOperator enum
func IntentFilterOperator_Values() []string {
	return []string{
		IntentFilterOperatorCo,
		IntentFilterOperatorEq,
	}
}

const (
	// IntentSortAttributeIntentName is a IntentSortAttribute enum value
	IntentSortAttributeIntentName = "IntentName"

	// IntentSortAttributeLastUpdatedDateTime is a IntentSortAttribute enum value
	IntentSortAttributeLastUpdatedDateTime = "LastUpdatedDateTime"
)

// IntentSortAttribute_Values returns all elements of the IntentSortAttribute enum
func IntentSortAttribute_Values() []string {
	return []string{
		IntentSortAttributeIntentName,
		IntentSortAttributeLastUpdatedDateTime,
	}
}

const (
	// MergeStrategyOverwrite is a MergeStrategy enum value
	MergeStrategyOverwrite = "Overwrite"

	// MergeStrategyFailOnConflict is a MergeStrategy enum value
	MergeStrategyFailOnConflict = "FailOnConflict"
)

// MergeStrategy_Values returns all elements of the MergeStrategy enum
func MergeStrategy_Values() []string {
	return []string{
		MergeStrategyOverwrite,
		MergeStrategyFailOnConflict,
	}
}

const (
	// ObfuscationSettingTypeNone is a ObfuscationSettingType enum value
	ObfuscationSettingTypeNone = "None"

	// ObfuscationSettingTypeDefaultObfuscation is a ObfuscationSettingType enum value
	ObfuscationSettingTypeDefaultObfuscation = "DefaultObfuscation"
)

// ObfuscationSettingType_Values returns all elements of the ObfuscationSettingType enum
func ObfuscationSettingType_Values() []string {
	return []string{
		ObfuscationSettingTypeNone,
		ObfuscationSettingTypeDefaultObfuscation,
	}
}

const (
	// SlotConstraintRequired is a SlotConstraint enum value
	SlotConstraintRequired = "Required"

	// SlotConstraintOptional is a SlotConstraint enum value
	SlotConstraintOptional = "Optional"
)

// SlotConstraint_Values returns all elements of the SlotConstraint enum
func SlotConstraint_Values() []string {
	return []string{
		SlotConstraintRequired,
		SlotConstraintOptional,
	}
}

const (
	// SlotFilterNameSlotName is a SlotFilterName enum value
	SlotFilterNameSlotName = "SlotName"
)

// SlotFilterName_Values returns all elements of the SlotFilterName enum
func SlotFilterName_Values() []string {
	return []string{
		SlotFilterNameSlotName,
	}
}

const (
	// SlotFilterOperatorCo is a SlotFilterOperator enum value
	SlotFilterOperatorCo = "CO"

	// SlotFilterOperatorEq is a SlotFilterOperator enum value
	SlotFilterOperatorEq = "EQ"
)

// SlotFilterOperator_Values returns all elements of the SlotFilterOperator enum
func SlotFilterOperator_Values() []string {
	return []string{
		SlotFilterOperatorCo,
		SlotFilterOperatorEq,
	}
}

const (
	// SlotSortAttributeSlotName is a SlotSortAttribute enum value
	SlotSortAttributeSlotName = "SlotName"

	// SlotSortAttributeLastUpdatedDateTime is a SlotSortAttribute enum value
	SlotSortAttributeLastUpdatedDateTime = "LastUpdatedDateTime"
)

// SlotSortAttribute_Values returns all elements of the SlotSortAttribute enum
func SlotSortAttribute_Values() []string {
	return []string{
		SlotSortAttributeSlotName,
		SlotSortAttributeLastUpdatedDateTime,
	}
}

const (
	// SlotTypeFilterNameSlotTypeName is a SlotTypeFilterName enum value
	SlotTypeFilterNameSlotTypeName = "SlotTypeName"
)

// SlotTypeFilterName_Values returns all elements of the SlotTypeFilterName enum
func SlotTypeFilterName_Values() []string {
	return []string{
		SlotTypeFilterNameSlotTypeName,
	}
}

const (
	// SlotTypeFilterOperatorCo is a SlotTypeFilterOperator enum value
	SlotTypeFilterOperatorCo = "CO"

	// SlotTypeFilterOperatorEq is a SlotTypeFilterOperator enum value
	SlotTypeFilterOperatorEq = "EQ"
)

// SlotTypeFilterOperator_Values returns all elements of the SlotTypeFilterOperator enum
func SlotTypeFilterOperator_Values() []string {
	return []string{
		SlotTypeFilterOperatorCo,
		SlotTypeFilterOperatorEq,
	}
}

const (
	// SlotTypeSortAttributeSlotTypeName is a SlotTypeSortAttribute enum value
	SlotTypeSortAttributeSlotTypeName = "SlotTypeName"

	// SlotTypeSortAttributeLastUpdatedDateTime is a SlotTypeSortAttribute enum value
	SlotTypeSortAttributeLastUpdatedDateTime = "LastUpdatedDateTime"
)

// SlotTypeSortAttribute_Values returns all elements of the SlotTypeSortAttribute enum
func SlotTypeSortAttribute_Values() []string {
	return []string{
		SlotTypeSortAttributeSlotTypeName,
		SlotTypeSortAttributeLastUpdatedDateTime,
	}
}

const (
	// SlotValueResolutionStrategyOriginalValue is a SlotValueResolutionStrategy enum value
	SlotValueResolutionStrategyOriginalValue = "OriginalValue"

	// SlotValueResolutionStrategyTopResolution is a SlotValueResolutionStrategy enum value
	SlotValueResolutionStrategyTopResolution = "TopResolution"
)

// SlotValueResolutionStrategy_Values returns all elements of the SlotValueResolutionStrategy enum
func SlotValueResolutionStrategy_Values() []string {
	return []string{
		SlotValueResolutionStrategyOriginalValue,
		SlotValueResolutionStrategyTopResolution,
	}
}

const (
	// SortOrderAscending is a SortOrder enum value
	SortOrderAscending = "Ascending"

	// SortOrderDescending is a SortOrder enum value
	SortOrderDescending = "Descending"
)

// SortOrder_Values returns all elements of the SortOrder enum
func SortOrder_Values() []string {
	return []string{
		SortOrderAscending,
		SortOrderDescending,
	}
}
