api.go

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

package cloudsearch

import (
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/internal/awsutil"
)

const opBuildSuggesters = "BuildSuggesters"

// BuildSuggestersRequest is a API request type for the BuildSuggesters API operation.
type BuildSuggestersRequest struct {
	*aws.Request
	Input *BuildSuggestersInput
	Copy  func(*BuildSuggestersInput) BuildSuggestersRequest
}

// Send marshals and sends the BuildSuggesters API request.
func (r BuildSuggestersRequest) Send() (*BuildSuggestersOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*BuildSuggestersOutput), nil
}

// BuildSuggestersRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Indexes the search suggestions. For more information, see Configuring Suggesters
// (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/getting-suggestions.html#configuring-suggesters)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the BuildSuggestersRequest method.
//    req := client.BuildSuggestersRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) BuildSuggestersRequest(input *BuildSuggestersInput) BuildSuggestersRequest {
	op := &aws.Operation{
		Name:       opBuildSuggesters,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &BuildSuggestersInput{}
	}

	output := &BuildSuggestersOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return BuildSuggestersRequest{Request: req, Input: input, Copy: c.BuildSuggestersRequest}
}

const opCreateDomain = "CreateDomain"

// CreateDomainRequest is a API request type for the CreateDomain API operation.
type CreateDomainRequest struct {
	*aws.Request
	Input *CreateDomainInput
	Copy  func(*CreateDomainInput) CreateDomainRequest
}

// Send marshals and sends the CreateDomain API request.
func (r CreateDomainRequest) Send() (*CreateDomainOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateDomainOutput), nil
}

// CreateDomainRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Creates a new search domain. For more information, see Creating a Search
// Domain (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/creating-domains.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the CreateDomainRequest method.
//    req := client.CreateDomainRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) CreateDomainRequest(input *CreateDomainInput) CreateDomainRequest {
	op := &aws.Operation{
		Name:       opCreateDomain,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateDomainInput{}
	}

	output := &CreateDomainOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateDomainRequest{Request: req, Input: input, Copy: c.CreateDomainRequest}
}

const opDefineAnalysisScheme = "DefineAnalysisScheme"

// DefineAnalysisSchemeRequest is a API request type for the DefineAnalysisScheme API operation.
type DefineAnalysisSchemeRequest struct {
	*aws.Request
	Input *DefineAnalysisSchemeInput
	Copy  func(*DefineAnalysisSchemeInput) DefineAnalysisSchemeRequest
}

// Send marshals and sends the DefineAnalysisScheme API request.
func (r DefineAnalysisSchemeRequest) Send() (*DefineAnalysisSchemeOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DefineAnalysisSchemeOutput), nil
}

// DefineAnalysisSchemeRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Configures an analysis scheme that can be applied to a text or text-array
// field to define language-specific text processing options. For more information,
// see Configuring Analysis Schemes (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-analysis-schemes.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DefineAnalysisSchemeRequest method.
//    req := client.DefineAnalysisSchemeRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DefineAnalysisSchemeRequest(input *DefineAnalysisSchemeInput) DefineAnalysisSchemeRequest {
	op := &aws.Operation{
		Name:       opDefineAnalysisScheme,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DefineAnalysisSchemeInput{}
	}

	output := &DefineAnalysisSchemeOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DefineAnalysisSchemeRequest{Request: req, Input: input, Copy: c.DefineAnalysisSchemeRequest}
}

const opDefineExpression = "DefineExpression"

// DefineExpressionRequest is a API request type for the DefineExpression API operation.
type DefineExpressionRequest struct {
	*aws.Request
	Input *DefineExpressionInput
	Copy  func(*DefineExpressionInput) DefineExpressionRequest
}

// Send marshals and sends the DefineExpression API request.
func (r DefineExpressionRequest) Send() (*DefineExpressionOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DefineExpressionOutput), nil
}

// DefineExpressionRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Configures an Expression for the search domain. Used to create new expressions
// and modify existing ones. If the expression exists, the new configuration
// replaces the old one. For more information, see Configuring Expressions (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-expressions.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DefineExpressionRequest method.
//    req := client.DefineExpressionRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DefineExpressionRequest(input *DefineExpressionInput) DefineExpressionRequest {
	op := &aws.Operation{
		Name:       opDefineExpression,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DefineExpressionInput{}
	}

	output := &DefineExpressionOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DefineExpressionRequest{Request: req, Input: input, Copy: c.DefineExpressionRequest}
}

const opDefineIndexField = "DefineIndexField"

// DefineIndexFieldRequest is a API request type for the DefineIndexField API operation.
type DefineIndexFieldRequest struct {
	*aws.Request
	Input *DefineIndexFieldInput
	Copy  func(*DefineIndexFieldInput) DefineIndexFieldRequest
}

// Send marshals and sends the DefineIndexField API request.
func (r DefineIndexFieldRequest) Send() (*DefineIndexFieldOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DefineIndexFieldOutput), nil
}

// DefineIndexFieldRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Configures an IndexField for the search domain. Used to create new fields
// and modify existing ones. You must specify the name of the domain you are
// configuring and an index field configuration. The index field configuration
// specifies a unique name, the index field type, and the options you want to
// configure for the field. The options you can specify depend on the IndexFieldType.
// If the field exists, the new configuration replaces the old one. For more
// information, see Configuring Index Fields (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-index-fields.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DefineIndexFieldRequest method.
//    req := client.DefineIndexFieldRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DefineIndexFieldRequest(input *DefineIndexFieldInput) DefineIndexFieldRequest {
	op := &aws.Operation{
		Name:       opDefineIndexField,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DefineIndexFieldInput{}
	}

	output := &DefineIndexFieldOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DefineIndexFieldRequest{Request: req, Input: input, Copy: c.DefineIndexFieldRequest}
}

const opDefineSuggester = "DefineSuggester"

// DefineSuggesterRequest is a API request type for the DefineSuggester API operation.
type DefineSuggesterRequest struct {
	*aws.Request
	Input *DefineSuggesterInput
	Copy  func(*DefineSuggesterInput) DefineSuggesterRequest
}

// Send marshals and sends the DefineSuggester API request.
func (r DefineSuggesterRequest) Send() (*DefineSuggesterOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DefineSuggesterOutput), nil
}

// DefineSuggesterRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Configures a suggester for a domain. A suggester enables you to display possible
// matches before users finish typing their queries. When you configure a suggester,
// you must specify the name of the text field you want to search for possible
// matches and a unique name for the suggester. For more information, see Getting
// Search Suggestions (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/getting-suggestions.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DefineSuggesterRequest method.
//    req := client.DefineSuggesterRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DefineSuggesterRequest(input *DefineSuggesterInput) DefineSuggesterRequest {
	op := &aws.Operation{
		Name:       opDefineSuggester,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DefineSuggesterInput{}
	}

	output := &DefineSuggesterOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DefineSuggesterRequest{Request: req, Input: input, Copy: c.DefineSuggesterRequest}
}

const opDeleteAnalysisScheme = "DeleteAnalysisScheme"

// DeleteAnalysisSchemeRequest is a API request type for the DeleteAnalysisScheme API operation.
type DeleteAnalysisSchemeRequest struct {
	*aws.Request
	Input *DeleteAnalysisSchemeInput
	Copy  func(*DeleteAnalysisSchemeInput) DeleteAnalysisSchemeRequest
}

// Send marshals and sends the DeleteAnalysisScheme API request.
func (r DeleteAnalysisSchemeRequest) Send() (*DeleteAnalysisSchemeOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteAnalysisSchemeOutput), nil
}

// DeleteAnalysisSchemeRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Deletes an analysis scheme. For more information, see Configuring Analysis
// Schemes (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-analysis-schemes.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DeleteAnalysisSchemeRequest method.
//    req := client.DeleteAnalysisSchemeRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DeleteAnalysisSchemeRequest(input *DeleteAnalysisSchemeInput) DeleteAnalysisSchemeRequest {
	op := &aws.Operation{
		Name:       opDeleteAnalysisScheme,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteAnalysisSchemeInput{}
	}

	output := &DeleteAnalysisSchemeOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteAnalysisSchemeRequest{Request: req, Input: input, Copy: c.DeleteAnalysisSchemeRequest}
}

const opDeleteDomain = "DeleteDomain"

// DeleteDomainRequest is a API request type for the DeleteDomain API operation.
type DeleteDomainRequest struct {
	*aws.Request
	Input *DeleteDomainInput
	Copy  func(*DeleteDomainInput) DeleteDomainRequest
}

// Send marshals and sends the DeleteDomain API request.
func (r DeleteDomainRequest) Send() (*DeleteDomainOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteDomainOutput), nil
}

// DeleteDomainRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Permanently deletes a search domain and all of its data. Once a domain has
// been deleted, it cannot be recovered. For more information, see Deleting
// a Search Domain (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/deleting-domains.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DeleteDomainRequest method.
//    req := client.DeleteDomainRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DeleteDomainRequest(input *DeleteDomainInput) DeleteDomainRequest {
	op := &aws.Operation{
		Name:       opDeleteDomain,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteDomainInput{}
	}

	output := &DeleteDomainOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteDomainRequest{Request: req, Input: input, Copy: c.DeleteDomainRequest}
}

const opDeleteExpression = "DeleteExpression"

// DeleteExpressionRequest is a API request type for the DeleteExpression API operation.
type DeleteExpressionRequest struct {
	*aws.Request
	Input *DeleteExpressionInput
	Copy  func(*DeleteExpressionInput) DeleteExpressionRequest
}

// Send marshals and sends the DeleteExpression API request.
func (r DeleteExpressionRequest) Send() (*DeleteExpressionOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteExpressionOutput), nil
}

// DeleteExpressionRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Removes an Expression from the search domain. For more information, see Configuring
// Expressions (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-expressions.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DeleteExpressionRequest method.
//    req := client.DeleteExpressionRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DeleteExpressionRequest(input *DeleteExpressionInput) DeleteExpressionRequest {
	op := &aws.Operation{
		Name:       opDeleteExpression,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteExpressionInput{}
	}

	output := &DeleteExpressionOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteExpressionRequest{Request: req, Input: input, Copy: c.DeleteExpressionRequest}
}

const opDeleteIndexField = "DeleteIndexField"

// DeleteIndexFieldRequest is a API request type for the DeleteIndexField API operation.
type DeleteIndexFieldRequest struct {
	*aws.Request
	Input *DeleteIndexFieldInput
	Copy  func(*DeleteIndexFieldInput) DeleteIndexFieldRequest
}

// Send marshals and sends the DeleteIndexField API request.
func (r DeleteIndexFieldRequest) Send() (*DeleteIndexFieldOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteIndexFieldOutput), nil
}

// DeleteIndexFieldRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Removes an IndexField from the search domain. For more information, see Configuring
// Index Fields (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-index-fields.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DeleteIndexFieldRequest method.
//    req := client.DeleteIndexFieldRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DeleteIndexFieldRequest(input *DeleteIndexFieldInput) DeleteIndexFieldRequest {
	op := &aws.Operation{
		Name:       opDeleteIndexField,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteIndexFieldInput{}
	}

	output := &DeleteIndexFieldOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteIndexFieldRequest{Request: req, Input: input, Copy: c.DeleteIndexFieldRequest}
}

const opDeleteSuggester = "DeleteSuggester"

// DeleteSuggesterRequest is a API request type for the DeleteSuggester API operation.
type DeleteSuggesterRequest struct {
	*aws.Request
	Input *DeleteSuggesterInput
	Copy  func(*DeleteSuggesterInput) DeleteSuggesterRequest
}

// Send marshals and sends the DeleteSuggester API request.
func (r DeleteSuggesterRequest) Send() (*DeleteSuggesterOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteSuggesterOutput), nil
}

// DeleteSuggesterRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Deletes a suggester. For more information, see Getting Search Suggestions
// (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/getting-suggestions.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DeleteSuggesterRequest method.
//    req := client.DeleteSuggesterRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DeleteSuggesterRequest(input *DeleteSuggesterInput) DeleteSuggesterRequest {
	op := &aws.Operation{
		Name:       opDeleteSuggester,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteSuggesterInput{}
	}

	output := &DeleteSuggesterOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteSuggesterRequest{Request: req, Input: input, Copy: c.DeleteSuggesterRequest}
}

const opDescribeAnalysisSchemes = "DescribeAnalysisSchemes"

// DescribeAnalysisSchemesRequest is a API request type for the DescribeAnalysisSchemes API operation.
type DescribeAnalysisSchemesRequest struct {
	*aws.Request
	Input *DescribeAnalysisSchemesInput
	Copy  func(*DescribeAnalysisSchemesInput) DescribeAnalysisSchemesRequest
}

// Send marshals and sends the DescribeAnalysisSchemes API request.
func (r DescribeAnalysisSchemesRequest) Send() (*DescribeAnalysisSchemesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeAnalysisSchemesOutput), nil
}

// DescribeAnalysisSchemesRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Gets the analysis schemes configured for a domain. An analysis scheme defines
// language-specific text processing options for a text field. Can be limited
// to specific analysis schemes by name. By default, shows all analysis schemes
// and includes any pending changes to the configuration. Set the Deployed option
// to true to show the active configuration and exclude pending changes. For
// more information, see Configuring Analysis Schemes (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-analysis-schemes.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DescribeAnalysisSchemesRequest method.
//    req := client.DescribeAnalysisSchemesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DescribeAnalysisSchemesRequest(input *DescribeAnalysisSchemesInput) DescribeAnalysisSchemesRequest {
	op := &aws.Operation{
		Name:       opDescribeAnalysisSchemes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeAnalysisSchemesInput{}
	}

	output := &DescribeAnalysisSchemesOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeAnalysisSchemesRequest{Request: req, Input: input, Copy: c.DescribeAnalysisSchemesRequest}
}

const opDescribeAvailabilityOptions = "DescribeAvailabilityOptions"

// DescribeAvailabilityOptionsRequest is a API request type for the DescribeAvailabilityOptions API operation.
type DescribeAvailabilityOptionsRequest struct {
	*aws.Request
	Input *DescribeAvailabilityOptionsInput
	Copy  func(*DescribeAvailabilityOptionsInput) DescribeAvailabilityOptionsRequest
}

// Send marshals and sends the DescribeAvailabilityOptions API request.
func (r DescribeAvailabilityOptionsRequest) Send() (*DescribeAvailabilityOptionsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeAvailabilityOptionsOutput), nil
}

// DescribeAvailabilityOptionsRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Gets the availability options configured for a domain. By default, shows
// the configuration with any pending changes. Set the Deployed option to true
// to show the active configuration and exclude pending changes. For more information,
// see Configuring Availability Options (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-availability-options.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DescribeAvailabilityOptionsRequest method.
//    req := client.DescribeAvailabilityOptionsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DescribeAvailabilityOptionsRequest(input *DescribeAvailabilityOptionsInput) DescribeAvailabilityOptionsRequest {
	op := &aws.Operation{
		Name:       opDescribeAvailabilityOptions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeAvailabilityOptionsInput{}
	}

	output := &DescribeAvailabilityOptionsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeAvailabilityOptionsRequest{Request: req, Input: input, Copy: c.DescribeAvailabilityOptionsRequest}
}

const opDescribeDomains = "DescribeDomains"

// DescribeDomainsRequest is a API request type for the DescribeDomains API operation.
type DescribeDomainsRequest struct {
	*aws.Request
	Input *DescribeDomainsInput
	Copy  func(*DescribeDomainsInput) DescribeDomainsRequest
}

// Send marshals and sends the DescribeDomains API request.
func (r DescribeDomainsRequest) Send() (*DescribeDomainsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeDomainsOutput), nil
}

// DescribeDomainsRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Gets information about the search domains owned by this account. Can be limited
// to specific domains. Shows all domains by default. To get the number of searchable
// documents in a domain, use the console or submit a matchall request to your
// domain's search endpoint: q=matchall&q.parser=structured&size=0.
// For more information, see Getting Information about a Search Domain (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/getting-domain-info.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DescribeDomainsRequest method.
//    req := client.DescribeDomainsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DescribeDomainsRequest(input *DescribeDomainsInput) DescribeDomainsRequest {
	op := &aws.Operation{
		Name:       opDescribeDomains,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeDomainsInput{}
	}

	output := &DescribeDomainsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeDomainsRequest{Request: req, Input: input, Copy: c.DescribeDomainsRequest}
}

const opDescribeExpressions = "DescribeExpressions"

// DescribeExpressionsRequest is a API request type for the DescribeExpressions API operation.
type DescribeExpressionsRequest struct {
	*aws.Request
	Input *DescribeExpressionsInput
	Copy  func(*DescribeExpressionsInput) DescribeExpressionsRequest
}

// Send marshals and sends the DescribeExpressions API request.
func (r DescribeExpressionsRequest) Send() (*DescribeExpressionsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeExpressionsOutput), nil
}

// DescribeExpressionsRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Gets the expressions configured for the search domain. Can be limited to
// specific expressions by name. By default, shows all expressions and includes
// any pending changes to the configuration. Set the Deployed option to true
// to show the active configuration and exclude pending changes. For more information,
// see Configuring Expressions (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-expressions.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DescribeExpressionsRequest method.
//    req := client.DescribeExpressionsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DescribeExpressionsRequest(input *DescribeExpressionsInput) DescribeExpressionsRequest {
	op := &aws.Operation{
		Name:       opDescribeExpressions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeExpressionsInput{}
	}

	output := &DescribeExpressionsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeExpressionsRequest{Request: req, Input: input, Copy: c.DescribeExpressionsRequest}
}

const opDescribeIndexFields = "DescribeIndexFields"

// DescribeIndexFieldsRequest is a API request type for the DescribeIndexFields API operation.
type DescribeIndexFieldsRequest struct {
	*aws.Request
	Input *DescribeIndexFieldsInput
	Copy  func(*DescribeIndexFieldsInput) DescribeIndexFieldsRequest
}

// Send marshals and sends the DescribeIndexFields API request.
func (r DescribeIndexFieldsRequest) Send() (*DescribeIndexFieldsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeIndexFieldsOutput), nil
}

// DescribeIndexFieldsRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Gets information about the index fields configured for the search domain.
// Can be limited to specific fields by name. By default, shows all fields and
// includes any pending changes to the configuration. Set the Deployed option
// to true to show the active configuration and exclude pending changes. For
// more information, see Getting Domain Information (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/getting-domain-info.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DescribeIndexFieldsRequest method.
//    req := client.DescribeIndexFieldsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DescribeIndexFieldsRequest(input *DescribeIndexFieldsInput) DescribeIndexFieldsRequest {
	op := &aws.Operation{
		Name:       opDescribeIndexFields,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeIndexFieldsInput{}
	}

	output := &DescribeIndexFieldsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeIndexFieldsRequest{Request: req, Input: input, Copy: c.DescribeIndexFieldsRequest}
}

const opDescribeScalingParameters = "DescribeScalingParameters"

// DescribeScalingParametersRequest is a API request type for the DescribeScalingParameters API operation.
type DescribeScalingParametersRequest struct {
	*aws.Request
	Input *DescribeScalingParametersInput
	Copy  func(*DescribeScalingParametersInput) DescribeScalingParametersRequest
}

// Send marshals and sends the DescribeScalingParameters API request.
func (r DescribeScalingParametersRequest) Send() (*DescribeScalingParametersOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeScalingParametersOutput), nil
}

// DescribeScalingParametersRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Gets the scaling parameters configured for a domain. A domain's scaling parameters
// specify the desired search instance type and replication count. For more
// information, see Configuring Scaling Options (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-scaling-options.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DescribeScalingParametersRequest method.
//    req := client.DescribeScalingParametersRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DescribeScalingParametersRequest(input *DescribeScalingParametersInput) DescribeScalingParametersRequest {
	op := &aws.Operation{
		Name:       opDescribeScalingParameters,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeScalingParametersInput{}
	}

	output := &DescribeScalingParametersOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeScalingParametersRequest{Request: req, Input: input, Copy: c.DescribeScalingParametersRequest}
}

const opDescribeServiceAccessPolicies = "DescribeServiceAccessPolicies"

// DescribeServiceAccessPoliciesRequest is a API request type for the DescribeServiceAccessPolicies API operation.
type DescribeServiceAccessPoliciesRequest struct {
	*aws.Request
	Input *DescribeServiceAccessPoliciesInput
	Copy  func(*DescribeServiceAccessPoliciesInput) DescribeServiceAccessPoliciesRequest
}

// Send marshals and sends the DescribeServiceAccessPolicies API request.
func (r DescribeServiceAccessPoliciesRequest) Send() (*DescribeServiceAccessPoliciesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeServiceAccessPoliciesOutput), nil
}

// DescribeServiceAccessPoliciesRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Gets information about the access policies that control access to the domain's
// document and search endpoints. By default, shows the configuration with any
// pending changes. Set the Deployed option to true to show the active configuration
// and exclude pending changes. For more information, see Configuring Access
// for a Search Domain (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-access.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DescribeServiceAccessPoliciesRequest method.
//    req := client.DescribeServiceAccessPoliciesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DescribeServiceAccessPoliciesRequest(input *DescribeServiceAccessPoliciesInput) DescribeServiceAccessPoliciesRequest {
	op := &aws.Operation{
		Name:       opDescribeServiceAccessPolicies,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeServiceAccessPoliciesInput{}
	}

	output := &DescribeServiceAccessPoliciesOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeServiceAccessPoliciesRequest{Request: req, Input: input, Copy: c.DescribeServiceAccessPoliciesRequest}
}

const opDescribeSuggesters = "DescribeSuggesters"

// DescribeSuggestersRequest is a API request type for the DescribeSuggesters API operation.
type DescribeSuggestersRequest struct {
	*aws.Request
	Input *DescribeSuggestersInput
	Copy  func(*DescribeSuggestersInput) DescribeSuggestersRequest
}

// Send marshals and sends the DescribeSuggesters API request.
func (r DescribeSuggestersRequest) Send() (*DescribeSuggestersOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeSuggestersOutput), nil
}

// DescribeSuggestersRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Gets the suggesters configured for a domain. A suggester enables you to display
// possible matches before users finish typing their queries. Can be limited
// to specific suggesters by name. By default, shows all suggesters and includes
// any pending changes to the configuration. Set the Deployed option to true
// to show the active configuration and exclude pending changes. For more information,
// see Getting Search Suggestions (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/getting-suggestions.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the DescribeSuggestersRequest method.
//    req := client.DescribeSuggestersRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) DescribeSuggestersRequest(input *DescribeSuggestersInput) DescribeSuggestersRequest {
	op := &aws.Operation{
		Name:       opDescribeSuggesters,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeSuggestersInput{}
	}

	output := &DescribeSuggestersOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeSuggestersRequest{Request: req, Input: input, Copy: c.DescribeSuggestersRequest}
}

const opIndexDocuments = "IndexDocuments"

// IndexDocumentsRequest is a API request type for the IndexDocuments API operation.
type IndexDocumentsRequest struct {
	*aws.Request
	Input *IndexDocumentsInput
	Copy  func(*IndexDocumentsInput) IndexDocumentsRequest
}

// Send marshals and sends the IndexDocuments API request.
func (r IndexDocumentsRequest) Send() (*IndexDocumentsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*IndexDocumentsOutput), nil
}

// IndexDocumentsRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Tells the search domain to start indexing its documents using the latest
// indexing options. This operation must be invoked to activate options whose
// OptionStatus is RequiresIndexDocuments.
//
//    // Example sending a request using the IndexDocumentsRequest method.
//    req := client.IndexDocumentsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) IndexDocumentsRequest(input *IndexDocumentsInput) IndexDocumentsRequest {
	op := &aws.Operation{
		Name:       opIndexDocuments,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &IndexDocumentsInput{}
	}

	output := &IndexDocumentsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return IndexDocumentsRequest{Request: req, Input: input, Copy: c.IndexDocumentsRequest}
}

const opListDomainNames = "ListDomainNames"

// ListDomainNamesRequest is a API request type for the ListDomainNames API operation.
type ListDomainNamesRequest struct {
	*aws.Request
	Input *ListDomainNamesInput
	Copy  func(*ListDomainNamesInput) ListDomainNamesRequest
}

// Send marshals and sends the ListDomainNames API request.
func (r ListDomainNamesRequest) Send() (*ListDomainNamesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListDomainNamesOutput), nil
}

// ListDomainNamesRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Lists all search domains owned by an account.
//
//    // Example sending a request using the ListDomainNamesRequest method.
//    req := client.ListDomainNamesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) ListDomainNamesRequest(input *ListDomainNamesInput) ListDomainNamesRequest {
	op := &aws.Operation{
		Name:       opListDomainNames,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListDomainNamesInput{}
	}

	output := &ListDomainNamesOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListDomainNamesRequest{Request: req, Input: input, Copy: c.ListDomainNamesRequest}
}

const opUpdateAvailabilityOptions = "UpdateAvailabilityOptions"

// UpdateAvailabilityOptionsRequest is a API request type for the UpdateAvailabilityOptions API operation.
type UpdateAvailabilityOptionsRequest struct {
	*aws.Request
	Input *UpdateAvailabilityOptionsInput
	Copy  func(*UpdateAvailabilityOptionsInput) UpdateAvailabilityOptionsRequest
}

// Send marshals and sends the UpdateAvailabilityOptions API request.
func (r UpdateAvailabilityOptionsRequest) Send() (*UpdateAvailabilityOptionsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateAvailabilityOptionsOutput), nil
}

// UpdateAvailabilityOptionsRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Configures the availability options for a domain. Enabling the Multi-AZ option
// expands an Amazon CloudSearch domain to an additional Availability Zone in
// the same Region to increase fault tolerance in the event of a service disruption.
// Changes to the Multi-AZ option can take about half an hour to become active.
// For more information, see Configuring Availability Options (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-availability-options.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the UpdateAvailabilityOptionsRequest method.
//    req := client.UpdateAvailabilityOptionsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) UpdateAvailabilityOptionsRequest(input *UpdateAvailabilityOptionsInput) UpdateAvailabilityOptionsRequest {
	op := &aws.Operation{
		Name:       opUpdateAvailabilityOptions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateAvailabilityOptionsInput{}
	}

	output := &UpdateAvailabilityOptionsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateAvailabilityOptionsRequest{Request: req, Input: input, Copy: c.UpdateAvailabilityOptionsRequest}
}

const opUpdateScalingParameters = "UpdateScalingParameters"

// UpdateScalingParametersRequest is a API request type for the UpdateScalingParameters API operation.
type UpdateScalingParametersRequest struct {
	*aws.Request
	Input *UpdateScalingParametersInput
	Copy  func(*UpdateScalingParametersInput) UpdateScalingParametersRequest
}

// Send marshals and sends the UpdateScalingParameters API request.
func (r UpdateScalingParametersRequest) Send() (*UpdateScalingParametersOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateScalingParametersOutput), nil
}

// UpdateScalingParametersRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Configures scaling parameters for a domain. A domain's scaling parameters
// specify the desired search instance type and replication count. Amazon CloudSearch
// will still automatically scale your domain based on the volume of data and
// traffic, but not below the desired instance type and replication count. If
// the Multi-AZ option is enabled, these values control the resources used per
// Availability Zone. For more information, see Configuring Scaling Options
// (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-scaling-options.html)
// in the Amazon CloudSearch Developer Guide.
//
//    // Example sending a request using the UpdateScalingParametersRequest method.
//    req := client.UpdateScalingParametersRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) UpdateScalingParametersRequest(input *UpdateScalingParametersInput) UpdateScalingParametersRequest {
	op := &aws.Operation{
		Name:       opUpdateScalingParameters,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateScalingParametersInput{}
	}

	output := &UpdateScalingParametersOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateScalingParametersRequest{Request: req, Input: input, Copy: c.UpdateScalingParametersRequest}
}

const opUpdateServiceAccessPolicies = "UpdateServiceAccessPolicies"

// UpdateServiceAccessPoliciesRequest is a API request type for the UpdateServiceAccessPolicies API operation.
type UpdateServiceAccessPoliciesRequest struct {
	*aws.Request
	Input *UpdateServiceAccessPoliciesInput
	Copy  func(*UpdateServiceAccessPoliciesInput) UpdateServiceAccessPoliciesRequest
}

// Send marshals and sends the UpdateServiceAccessPolicies API request.
func (r UpdateServiceAccessPoliciesRequest) Send() (*UpdateServiceAccessPoliciesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateServiceAccessPoliciesOutput), nil
}

// UpdateServiceAccessPoliciesRequest returns a request value for making API operation for
// Amazon CloudSearch.
//
// Configures the access rules that control access to the domain's document
// and search endpoints. For more information, see  Configuring Access for an
// Amazon CloudSearch Domain (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-access.html).
//
//    // Example sending a request using the UpdateServiceAccessPoliciesRequest method.
//    req := client.UpdateServiceAccessPoliciesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *CloudSearch) UpdateServiceAccessPoliciesRequest(input *UpdateServiceAccessPoliciesInput) UpdateServiceAccessPoliciesRequest {
	op := &aws.Operation{
		Name:       opUpdateServiceAccessPolicies,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateServiceAccessPoliciesInput{}
	}

	output := &UpdateServiceAccessPoliciesOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateServiceAccessPoliciesRequest{Request: req, Input: input, Copy: c.UpdateServiceAccessPoliciesRequest}
}

// The configured access rules for the domain's document and search endpoints,
// and the current status of those rules.
type AccessPoliciesStatus struct {
	_ struct{} `type:"structure"`

	// Access rules for a domain's document or search service endpoints. For more
	// information, see Configuring Access for a Search Domain (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-access.html)
	// in the Amazon CloudSearch Developer Guide. The maximum size of a policy document
	// is 100 KB.
	//
	// Options is a required field
	Options *string `type:"string" required:"true"`

	// The status of domain configuration option.
	//
	// Status is a required field
	Status *OptionStatus `type:"structure" required:"true"`
}

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

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

// Synonyms, stopwords, and stemming options for an analysis scheme. Includes
// tokenization dictionary for Japanese.
type AnalysisOptions struct {
	_ struct{} `type:"structure"`

	// The level of algorithmic stemming to perform: none, minimal, light, or full.
	// The available levels vary depending on the language. For more information,
	// see Language Specific Text Processing Settings (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/text-processing.html#text-processing-settings)
	// in the Amazon CloudSearch Developer Guide
	AlgorithmicStemming AlgorithmicStemming `type:"string" enum:"true"`

	// A JSON array that contains a collection of terms, tokens, readings and part
	// of speech for Japanese Tokenizaiton. The Japanese tokenization dictionary
	// enables you to override the default tokenization for selected terms. This
	// is only valid for Japanese language fields.
	JapaneseTokenizationDictionary *string `type:"string"`

	// A JSON object that contains a collection of string:value pairs that each
	// map a term to its stem. For example, {"term1": "stem1", "term2": "stem2",
	// "term3": "stem3"}. The stemming dictionary is applied in addition to any
	// algorithmic stemming. This enables you to override the results of the algorithmic
	// stemming to correct specific cases of overstemming or understemming. The
	// maximum size of a stemming dictionary is 500 KB.
	StemmingDictionary *string `type:"string"`

	// A JSON array of terms to ignore during indexing and searching. For example,
	// ["a", "an", "the", "of"]. The stopwords dictionary must explicitly list each
	// word you want to ignore. Wildcards and regular expressions are not supported.
	Stopwords *string `type:"string"`

	// A JSON object that defines synonym groups and aliases. A synonym group is
	// an array of arrays, where each sub-array is a group of terms where each term
	// in the group is considered a synonym of every other term in the group. The
	// aliases value is an object that contains a collection of string:value pairs
	// where the string specifies a term and the array of values specifies each
	// of the aliases for that term. An alias is considered a synonym of the specified
	// term, but the term is not considered a synonym of the alias. For more information
	// about specifying synonyms, see Synonyms (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-analysis-schemes.html#synonyms)
	// in the Amazon CloudSearch Developer Guide.
	Synonyms *string `type:"string"`
}

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

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

// Configuration information for an analysis scheme. Each analysis scheme has
// a unique name and specifies the language of the text to be processed. The
// following options can be configured for an analysis scheme: Synonyms, Stopwords,
// StemmingDictionary, JapaneseTokenizationDictionary and AlgorithmicStemming.
type AnalysisScheme struct {
	_ struct{} `type:"structure"`

	// Synonyms, stopwords, and stemming options for an analysis scheme. Includes
	// tokenization dictionary for Japanese.
	AnalysisOptions *AnalysisOptions `type:"structure"`

	// An IETF RFC 4646 (http://tools.ietf.org/html/rfc4646) language code or mul
	// for multiple languages.
	//
	// AnalysisSchemeLanguage is a required field
	AnalysisSchemeLanguage AnalysisSchemeLanguage `type:"string" required:"true" enum:"true"`

	// Names must begin with a letter and can contain the following characters:
	// a-z (lowercase), 0-9, and _ (underscore).
	//
	// AnalysisSchemeName is a required field
	AnalysisSchemeName *string `min:"1" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *AnalysisScheme) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "AnalysisScheme"}
	if len(s.AnalysisSchemeLanguage) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("AnalysisSchemeLanguage"))
	}

	if s.AnalysisSchemeName == nil {
		invalidParams.Add(aws.NewErrParamRequired("AnalysisSchemeName"))
	}
	if s.AnalysisSchemeName != nil && len(*s.AnalysisSchemeName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("AnalysisSchemeName", 1))
	}

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

// The status and configuration of an AnalysisScheme.
type AnalysisSchemeStatus struct {
	_ struct{} `type:"structure"`

	// Configuration information for an analysis scheme. Each analysis scheme has
	// a unique name and specifies the language of the text to be processed. The
	// following options can be configured for an analysis scheme: Synonyms, Stopwords,
	// StemmingDictionary, JapaneseTokenizationDictionary and AlgorithmicStemming.
	//
	// Options is a required field
	Options *AnalysisScheme `type:"structure" required:"true"`

	// The status of domain configuration option.
	//
	// Status is a required field
	Status *OptionStatus `type:"structure" required:"true"`
}

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

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

// The status and configuration of the domain's availability options.
type AvailabilityOptionsStatus struct {
	_ struct{} `type:"structure"`

	// The availability options configured for the domain.
	//
	// Options is a required field
	Options *bool `type:"boolean" required:"true"`

	// The status of domain configuration option.
	//
	// Status is a required field
	Status *OptionStatus `type:"structure" required:"true"`
}

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

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

// Container for the parameters to the BuildSuggester operation. Specifies the
// name of the domain you want to update.
type BuildSuggestersInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *BuildSuggestersInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "BuildSuggestersInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a BuildSuggester request. Contains a list of the fields used
// for suggestions.
type BuildSuggestersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A list of field names.
	FieldNames []string `type:"list"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s BuildSuggestersOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the CreateDomain operation. Specifies a name
// for the new search domain.
type CreateDomainInput struct {
	_ struct{} `type:"structure"`

	// A name for the domain you are creating. Allowed characters are a-z (lower-case
	// letters), 0-9, and hyphen (-). Domain names must start with a letter or number
	// and be at least 3 and no more than 28 characters long.
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateDomainInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateDomainInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a CreateDomainRequest. Contains the status of a newly created
// domain.
type CreateDomainOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The current status of the search domain.
	DomainStatus *DomainStatus `type:"structure"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateDomainOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Options for a field that contains an array of dates. Present if IndexFieldType
// specifies the field is of type date-array. All options are enabled by default.
type DateArrayOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *string `type:"string"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// A list of source fields to map to the field.
	SourceFields *string `type:"string"`
}

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

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

// Options for a date field. Dates and times are specified in UTC (Coordinated
// Universal Time) according to IETF RFC3339: yyyy-mm-ddT00:00:00Z. Present
// if IndexFieldType specifies the field is of type date. All options are enabled
// by default.
type DateOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *string `type:"string"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// Whether the field can be used to sort the search results.
	SortEnabled *bool `type:"boolean"`

	// A string that represents the name of an index field. CloudSearch supports
	// regular index fields as well as dynamic fields. A dynamic field's name defines
	// a pattern that begins or ends with a wildcard. Any document fields that don't
	// map to a regular index field but do match a dynamic field's pattern are configured
	// with the dynamic field's indexing options.
	//
	// Regular field names begin with a letter and can contain the following characters:
	// a-z (lowercase), 0-9, and _ (underscore). Dynamic field names must begin
	// or end with a wildcard (*). The wildcard can also be the only character in
	// a dynamic field name. Multiple wildcards, and wildcards embedded within a
	// string are not supported.
	//
	// The name score is reserved and cannot be used as a field name. To reference
	// a document's ID, you can use the name _id.
	SourceField *string `min:"1" type:"string"`
}

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

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

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

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

// Container for the parameters to the DefineAnalysisScheme operation. Specifies
// the name of the domain you want to update and the analysis scheme configuration.
type DefineAnalysisSchemeInput struct {
	_ struct{} `type:"structure"`

	// Configuration information for an analysis scheme. Each analysis scheme has
	// a unique name and specifies the language of the text to be processed. The
	// following options can be configured for an analysis scheme: Synonyms, Stopwords,
	// StemmingDictionary, JapaneseTokenizationDictionary and AlgorithmicStemming.
	//
	// AnalysisScheme is a required field
	AnalysisScheme *AnalysisScheme `type:"structure" required:"true"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DefineAnalysisSchemeInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DefineAnalysisSchemeInput"}

	if s.AnalysisScheme == nil {
		invalidParams.Add(aws.NewErrParamRequired("AnalysisScheme"))
	}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}
	if s.AnalysisScheme != nil {
		if err := s.AnalysisScheme.Validate(); err != nil {
			invalidParams.AddNested("AnalysisScheme", err.(aws.ErrInvalidParams))
		}
	}

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

// The result of a DefineAnalysisScheme request. Contains the status of the
// newly-configured analysis scheme.
type DefineAnalysisSchemeOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The status and configuration of an AnalysisScheme.
	//
	// AnalysisScheme is a required field
	AnalysisScheme *AnalysisSchemeStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DefineAnalysisSchemeOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DefineExpression operation. Specifies
// the name of the domain you want to update and the expression you want to
// configure.
type DefineExpressionInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// A named expression that can be evaluated at search time. Can be used to sort
	// the search results, define other expressions, or return computed information
	// in the search results.
	//
	// Expression is a required field
	Expression *Expression `type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DefineExpressionInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DefineExpressionInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

	if s.Expression == nil {
		invalidParams.Add(aws.NewErrParamRequired("Expression"))
	}
	if s.Expression != nil {
		if err := s.Expression.Validate(); err != nil {
			invalidParams.AddNested("Expression", err.(aws.ErrInvalidParams))
		}
	}

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

// The result of a DefineExpression request. Contains the status of the newly-configured
// expression.
type DefineExpressionOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The value of an Expression and its current status.
	//
	// Expression is a required field
	Expression *ExpressionStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DefineExpressionOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DefineIndexField operation. Specifies
// the name of the domain you want to update and the index field configuration.
type DefineIndexFieldInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// The index field and field options you want to configure.
	//
	// IndexField is a required field
	IndexField *IndexField `type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DefineIndexFieldInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DefineIndexFieldInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

	if s.IndexField == nil {
		invalidParams.Add(aws.NewErrParamRequired("IndexField"))
	}
	if s.IndexField != nil {
		if err := s.IndexField.Validate(); err != nil {
			invalidParams.AddNested("IndexField", err.(aws.ErrInvalidParams))
		}
	}

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

// The result of a DefineIndexField request. Contains the status of the newly-configured
// index field.
type DefineIndexFieldOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The value of an IndexField and its current status.
	//
	// IndexField is a required field
	IndexField *IndexFieldStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DefineIndexFieldOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DefineSuggester operation. Specifies
// the name of the domain you want to update and the suggester configuration.
type DefineSuggesterInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// Configuration information for a search suggester. Each suggester has a unique
	// name and specifies the text field you want to use for suggestions. The following
	// options can be configured for a suggester: FuzzyMatching, SortExpression.
	//
	// Suggester is a required field
	Suggester *Suggester `type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DefineSuggesterInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DefineSuggesterInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

	if s.Suggester == nil {
		invalidParams.Add(aws.NewErrParamRequired("Suggester"))
	}
	if s.Suggester != nil {
		if err := s.Suggester.Validate(); err != nil {
			invalidParams.AddNested("Suggester", err.(aws.ErrInvalidParams))
		}
	}

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

// The result of a DefineSuggester request. Contains the status of the newly-configured
// suggester.
type DefineSuggesterOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The value of a Suggester and its current status.
	//
	// Suggester is a required field
	Suggester *SuggesterStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DefineSuggesterOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DeleteAnalysisScheme operation. Specifies
// the name of the domain you want to update and the analysis scheme you want
// to delete.
type DeleteAnalysisSchemeInput struct {
	_ struct{} `type:"structure"`

	// The name of the analysis scheme you want to delete.
	//
	// AnalysisSchemeName is a required field
	AnalysisSchemeName *string `min:"1" type:"string" required:"true"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteAnalysisSchemeInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteAnalysisSchemeInput"}

	if s.AnalysisSchemeName == nil {
		invalidParams.Add(aws.NewErrParamRequired("AnalysisSchemeName"))
	}
	if s.AnalysisSchemeName != nil && len(*s.AnalysisSchemeName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("AnalysisSchemeName", 1))
	}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DeleteAnalysisScheme request. Contains the status of the
// deleted analysis scheme.
type DeleteAnalysisSchemeOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The status of the analysis scheme being deleted.
	//
	// AnalysisScheme is a required field
	AnalysisScheme *AnalysisSchemeStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteAnalysisSchemeOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DeleteDomain operation. Specifies the
// name of the domain you want to delete.
type DeleteDomainInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain you want to permanently delete.
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteDomainInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteDomainInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DeleteDomain request. Contains the status of a newly deleted
// domain, or no status if the domain has already been completely deleted.
type DeleteDomainOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The current status of the search domain.
	DomainStatus *DomainStatus `type:"structure"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteDomainOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DeleteExpression operation. Specifies
// the name of the domain you want to update and the name of the expression
// you want to delete.
type DeleteExpressionInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// The name of the Expression to delete.
	//
	// ExpressionName is a required field
	ExpressionName *string `min:"1" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteExpressionInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteExpressionInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

	if s.ExpressionName == nil {
		invalidParams.Add(aws.NewErrParamRequired("ExpressionName"))
	}
	if s.ExpressionName != nil && len(*s.ExpressionName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ExpressionName", 1))
	}

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

// The result of a DeleteExpression request. Specifies the expression being
// deleted.
type DeleteExpressionOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The status of the expression being deleted.
	//
	// Expression is a required field
	Expression *ExpressionStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteExpressionOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DeleteIndexField operation. Specifies
// the name of the domain you want to update and the name of the index field
// you want to delete.
type DeleteIndexFieldInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// The name of the index field your want to remove from the domain's indexing
	// options.
	//
	// IndexFieldName is a required field
	IndexFieldName *string `min:"1" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteIndexFieldInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteIndexFieldInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

	if s.IndexFieldName == nil {
		invalidParams.Add(aws.NewErrParamRequired("IndexFieldName"))
	}
	if s.IndexFieldName != nil && len(*s.IndexFieldName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("IndexFieldName", 1))
	}

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

// The result of a DeleteIndexField request.
type DeleteIndexFieldOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The status of the index field being deleted.
	//
	// IndexField is a required field
	IndexField *IndexFieldStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteIndexFieldOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DeleteSuggester operation. Specifies
// the name of the domain you want to update and name of the suggester you want
// to delete.
type DeleteSuggesterInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// Specifies the name of the suggester you want to delete.
	//
	// SuggesterName is a required field
	SuggesterName *string `min:"1" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteSuggesterInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteSuggesterInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

	if s.SuggesterName == nil {
		invalidParams.Add(aws.NewErrParamRequired("SuggesterName"))
	}
	if s.SuggesterName != nil && len(*s.SuggesterName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SuggesterName", 1))
	}

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

// The result of a DeleteSuggester request. Contains the status of the deleted
// suggester.
type DeleteSuggesterOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The status of the suggester being deleted.
	//
	// Suggester is a required field
	Suggester *SuggesterStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteSuggesterOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DescribeAnalysisSchemes operation. Specifies
// the name of the domain you want to describe. To limit the response to particular
// analysis schemes, specify the names of the analysis schemes you want to describe.
// To show the active configuration and exclude any pending changes, set the
// Deployed option to true.
type DescribeAnalysisSchemesInput struct {
	_ struct{} `type:"structure"`

	// The analysis schemes you want to describe.
	AnalysisSchemeNames []string `type:"list"`

	// Whether to display the deployed configuration (true) or include any pending
	// changes (false). Defaults to false.
	Deployed *bool `type:"boolean"`

	// The name of the domain you want to describe.
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeAnalysisSchemesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeAnalysisSchemesInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DescribeAnalysisSchemes request. Contains the analysis schemes
// configured for the domain specified in the request.
type DescribeAnalysisSchemesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The analysis scheme descriptions.
	//
	// AnalysisSchemes is a required field
	AnalysisSchemes []AnalysisSchemeStatus `type:"list" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeAnalysisSchemesOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DescribeAvailabilityOptions operation.
// Specifies the name of the domain you want to describe. To show the active
// configuration and exclude any pending changes, set the Deployed option to
// true.
type DescribeAvailabilityOptionsInput struct {
	_ struct{} `type:"structure"`

	// Whether to display the deployed configuration (true) or include any pending
	// changes (false). Defaults to false.
	Deployed *bool `type:"boolean"`

	// The name of the domain you want to describe.
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeAvailabilityOptionsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeAvailabilityOptionsInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DescribeAvailabilityOptions request. Indicates whether or
// not the Multi-AZ option is enabled for the domain specified in the request.
type DescribeAvailabilityOptionsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The availability options configured for the domain. Indicates whether Multi-AZ
	// is enabled for the domain.
	AvailabilityOptions *AvailabilityOptionsStatus `type:"structure"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeAvailabilityOptionsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DescribeDomains operation. By default
// shows the status of all domains. To restrict the response to particular domains,
// specify the names of the domains you want to describe.
type DescribeDomainsInput struct {
	_ struct{} `type:"structure"`

	// The names of the domains you want to include in the response.
	DomainNames []string `type:"list"`
}

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

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

// The result of a DescribeDomains request. Contains the status of the domains
// specified in the request or all domains owned by the account.
type DescribeDomainsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A list that contains the status of each requested domain.
	//
	// DomainStatusList is a required field
	DomainStatusList []DomainStatus `type:"list" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeDomainsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DescribeDomains operation. Specifies
// the name of the domain you want to describe. To restrict the response to
// particular expressions, specify the names of the expressions you want to
// describe. To show the active configuration and exclude any pending changes,
// set the Deployed option to true.
type DescribeExpressionsInput struct {
	_ struct{} `type:"structure"`

	// Whether to display the deployed configuration (true) or include any pending
	// changes (false). Defaults to false.
	Deployed *bool `type:"boolean"`

	// The name of the domain you want to describe.
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// Limits the DescribeExpressions response to the specified expressions. If
	// not specified, all expressions are shown.
	ExpressionNames []string `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeExpressionsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeExpressionsInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DescribeExpressions request. Contains the expressions configured
// for the domain specified in the request.
type DescribeExpressionsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The expressions configured for the domain.
	//
	// Expressions is a required field
	Expressions []ExpressionStatus `type:"list" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeExpressionsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DescribeIndexFields operation. Specifies
// the name of the domain you want to describe. To restrict the response to
// particular index fields, specify the names of the index fields you want to
// describe. To show the active configuration and exclude any pending changes,
// set the Deployed option to true.
type DescribeIndexFieldsInput struct {
	_ struct{} `type:"structure"`

	// Whether to display the deployed configuration (true) or include any pending
	// changes (false). Defaults to false.
	Deployed *bool `type:"boolean"`

	// The name of the domain you want to describe.
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// A list of the index fields you want to describe. If not specified, information
	// is returned for all configured index fields.
	FieldNames []string `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeIndexFieldsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeIndexFieldsInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DescribeIndexFields request. Contains the index fields configured
// for the domain specified in the request.
type DescribeIndexFieldsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The index fields configured for the domain.
	//
	// IndexFields is a required field
	IndexFields []IndexFieldStatus `type:"list" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeIndexFieldsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DescribeScalingParameters operation.
// Specifies the name of the domain you want to describe.
type DescribeScalingParametersInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeScalingParametersInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeScalingParametersInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DescribeScalingParameters request. Contains the scaling parameters
// configured for the domain specified in the request.
type DescribeScalingParametersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The status and configuration of a search domain's scaling parameters.
	//
	// ScalingParameters is a required field
	ScalingParameters *ScalingParametersStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeScalingParametersOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DescribeServiceAccessPolicies operation.
// Specifies the name of the domain you want to describe. To show the active
// configuration and exclude any pending changes, set the Deployed option to
// true.
type DescribeServiceAccessPoliciesInput struct {
	_ struct{} `type:"structure"`

	// Whether to display the deployed configuration (true) or include any pending
	// changes (false). Defaults to false.
	Deployed *bool `type:"boolean"`

	// The name of the domain you want to describe.
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeServiceAccessPoliciesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeServiceAccessPoliciesInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DescribeServiceAccessPolicies request.
type DescribeServiceAccessPoliciesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The access rules configured for the domain specified in the request.
	//
	// AccessPolicies is a required field
	AccessPolicies *AccessPoliciesStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeServiceAccessPoliciesOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the DescribeSuggester operation. Specifies
// the name of the domain you want to describe. To restrict the response to
// particular suggesters, specify the names of the suggesters you want to describe.
// To show the active configuration and exclude any pending changes, set the
// Deployed option to true.
type DescribeSuggestersInput struct {
	_ struct{} `type:"structure"`

	// Whether to display the deployed configuration (true) or include any pending
	// changes (false). Defaults to false.
	Deployed *bool `type:"boolean"`

	// The name of the domain you want to describe.
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// The suggesters you want to describe.
	SuggesterNames []string `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeSuggestersInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeSuggestersInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of a DescribeSuggesters request.
type DescribeSuggestersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The suggesters configured for the domain specified in the request.
	//
	// Suggesters is a required field
	Suggesters []SuggesterStatus `type:"list" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeSuggestersOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Options for a search suggester.
type DocumentSuggesterOptions struct {
	_ struct{} `type:"structure"`

	// The level of fuzziness allowed when suggesting matches for a string: none,
	// low, or high. With none, the specified string is treated as an exact prefix.
	// With low, suggestions must differ from the specified string by no more than
	// one character. With high, suggestions can differ by up to two characters.
	// The default is none.
	FuzzyMatching SuggesterFuzzyMatching `type:"string" enum:"true"`

	// An expression that computes a score for each suggestion to control how they
	// are sorted. The scores are rounded to the nearest integer, with a floor of
	// 0 and a ceiling of 2^31-1. A document's relevance score is not computed for
	// suggestions, so sort expressions cannot reference the _score value. To sort
	// suggestions using a numeric field or existing expression, simply specify
	// the name of the field or expression. If no expression is configured for the
	// suggester, the suggestions are sorted with the closest matches listed first.
	SortExpression *string `type:"string"`

	// The name of the index field you want to use for suggestions.
	//
	// SourceField is a required field
	SourceField *string `min:"1" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DocumentSuggesterOptions) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DocumentSuggesterOptions"}

	if s.SourceField == nil {
		invalidParams.Add(aws.NewErrParamRequired("SourceField"))
	}
	if s.SourceField != nil && len(*s.SourceField) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SourceField", 1))
	}

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

// The current status of the search domain.
type DomainStatus struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the search domain. See Identifiers for
	// IAM Entities (http://docs.aws.amazon.com/IAM/latest/UserGuide/index.html?Using_Identifiers.html)
	// in Using AWS Identity and Access Management for more information.
	ARN *string `type:"string"`

	// True if the search domain is created. It can take several minutes to initialize
	// a domain when CreateDomain is called. Newly created search domains are returned
	// from DescribeDomains with a false value for Created until domain creation
	// is complete.
	Created *bool `type:"boolean"`

	// True if the search domain has been deleted. The system must clean up resources
	// dedicated to the search domain when DeleteDomain is called. Newly deleted
	// search domains are returned from DescribeDomains with a true value for IsDeleted
	// for several minutes until resource cleanup is complete.
	Deleted *bool `type:"boolean"`

	// The service endpoint for updating documents in a search domain.
	DocService *ServiceEndpoint `type:"structure"`

	// An internally generated unique identifier for a domain.
	//
	// DomainId is a required field
	DomainId *string `min:"1" type:"string" required:"true"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	Limits *Limits `type:"structure"`

	// True if processing is being done to activate the current domain configuration.
	Processing *bool `type:"boolean"`

	// True if IndexDocuments needs to be called to activate the current domain
	// configuration.
	//
	// RequiresIndexDocuments is a required field
	RequiresIndexDocuments *bool `type:"boolean" required:"true"`

	// The number of search instances that are available to process search requests.
	SearchInstanceCount *int64 `min:"1" type:"integer"`

	// The instance type that is being used to process search requests.
	SearchInstanceType *string `type:"string"`

	// The number of partitions across which the search index is spread.
	SearchPartitionCount *int64 `min:"1" type:"integer"`

	// The service endpoint for requesting search results from a search domain.
	SearchService *ServiceEndpoint `type:"structure"`
}

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

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

// Options for a field that contains an array of double-precision 64-bit floating
// point values. Present if IndexFieldType specifies the field is of type double-array.
// All options are enabled by default.
type DoubleArrayOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *float64 `type:"double"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// A list of source fields to map to the field.
	SourceFields *string `type:"string"`
}

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

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

// Options for a double-precision 64-bit floating point field. Present if IndexFieldType
// specifies the field is of type double. All options are enabled by default.
type DoubleOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	// This can be important if you are using the field in an expression and that
	// field is not present in every document.
	DefaultValue *float64 `type:"double"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// Whether the field can be used to sort the search results.
	SortEnabled *bool `type:"boolean"`

	// The name of the source field to map to the field.
	SourceField *string `min:"1" type:"string"`
}

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

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

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

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

// A named expression that can be evaluated at search time. Can be used to sort
// the search results, define other expressions, or return computed information
// in the search results.
type Expression struct {
	_ struct{} `type:"structure"`

	// Names must begin with a letter and can contain the following characters:
	// a-z (lowercase), 0-9, and _ (underscore).
	//
	// ExpressionName is a required field
	ExpressionName *string `min:"1" type:"string" required:"true"`

	// The expression to evaluate for sorting while processing a search request.
	// The Expression syntax is based on JavaScript expressions. For more information,
	// see Configuring Expressions (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-expressions.html)
	// in the Amazon CloudSearch Developer Guide.
	//
	// ExpressionValue is a required field
	ExpressionValue *string `min:"1" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *Expression) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Expression"}

	if s.ExpressionName == nil {
		invalidParams.Add(aws.NewErrParamRequired("ExpressionName"))
	}
	if s.ExpressionName != nil && len(*s.ExpressionName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ExpressionName", 1))
	}

	if s.ExpressionValue == nil {
		invalidParams.Add(aws.NewErrParamRequired("ExpressionValue"))
	}
	if s.ExpressionValue != nil && len(*s.ExpressionValue) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ExpressionValue", 1))
	}

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

// The value of an Expression and its current status.
type ExpressionStatus struct {
	_ struct{} `type:"structure"`

	// The expression that is evaluated for sorting while processing a search request.
	//
	// Options is a required field
	Options *Expression `type:"structure" required:"true"`

	// The status of domain configuration option.
	//
	// Status is a required field
	Status *OptionStatus `type:"structure" required:"true"`
}

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

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

// Container for the parameters to the IndexDocuments operation. Specifies the
// name of the domain you want to re-index.
type IndexDocumentsInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *IndexDocumentsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "IndexDocumentsInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of an IndexDocuments request. Contains the status of the indexing
// operation, including the fields being indexed.
type IndexDocumentsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The names of the fields that are currently being indexed.
	FieldNames []string `type:"list"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s IndexDocumentsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Configuration information for a field in the index, including its name, type,
// and options. The supported options depend on the IndexFieldType.
type IndexField struct {
	_ struct{} `type:"structure"`

	// Options for a field that contains an array of dates. Present if IndexFieldType
	// specifies the field is of type date-array. All options are enabled by default.
	DateArrayOptions *DateArrayOptions `type:"structure"`

	// Options for a date field. Dates and times are specified in UTC (Coordinated
	// Universal Time) according to IETF RFC3339: yyyy-mm-ddT00:00:00Z. Present
	// if IndexFieldType specifies the field is of type date. All options are enabled
	// by default.
	DateOptions *DateOptions `type:"structure"`

	// Options for a field that contains an array of double-precision 64-bit floating
	// point values. Present if IndexFieldType specifies the field is of type double-array.
	// All options are enabled by default.
	DoubleArrayOptions *DoubleArrayOptions `type:"structure"`

	// Options for a double-precision 64-bit floating point field. Present if IndexFieldType
	// specifies the field is of type double. All options are enabled by default.
	DoubleOptions *DoubleOptions `type:"structure"`

	// A string that represents the name of an index field. CloudSearch supports
	// regular index fields as well as dynamic fields. A dynamic field's name defines
	// a pattern that begins or ends with a wildcard. Any document fields that don't
	// map to a regular index field but do match a dynamic field's pattern are configured
	// with the dynamic field's indexing options.
	//
	// Regular field names begin with a letter and can contain the following characters:
	// a-z (lowercase), 0-9, and _ (underscore). Dynamic field names must begin
	// or end with a wildcard (*). The wildcard can also be the only character in
	// a dynamic field name. Multiple wildcards, and wildcards embedded within a
	// string are not supported.
	//
	// The name score is reserved and cannot be used as a field name. To reference
	// a document's ID, you can use the name _id.
	//
	// IndexFieldName is a required field
	IndexFieldName *string `min:"1" type:"string" required:"true"`

	// The type of field. The valid options for a field depend on the field type.
	// For more information about the supported field types, see Configuring Index
	// Fields (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-index-fields.html)
	// in the Amazon CloudSearch Developer Guide.
	//
	// IndexFieldType is a required field
	IndexFieldType IndexFieldType `type:"string" required:"true" enum:"true"`

	// Options for a field that contains an array of 64-bit signed integers. Present
	// if IndexFieldType specifies the field is of type int-array. All options are
	// enabled by default.
	IntArrayOptions *IntArrayOptions `type:"structure"`

	// Options for a 64-bit signed integer field. Present if IndexFieldType specifies
	// the field is of type int. All options are enabled by default.
	IntOptions *IntOptions `type:"structure"`

	// Options for a latlon field. A latlon field contains a location stored as
	// a latitude and longitude value pair. Present if IndexFieldType specifies
	// the field is of type latlon. All options are enabled by default.
	LatLonOptions *LatLonOptions `type:"structure"`

	// Options for a field that contains an array of literal strings. Present if
	// IndexFieldType specifies the field is of type literal-array. All options
	// are enabled by default.
	LiteralArrayOptions *LiteralArrayOptions `type:"structure"`

	// Options for literal field. Present if IndexFieldType specifies the field
	// is of type literal. All options are enabled by default.
	LiteralOptions *LiteralOptions `type:"structure"`

	// Options for a field that contains an array of text strings. Present if IndexFieldType
	// specifies the field is of type text-array. A text-array field is always searchable.
	// All options are enabled by default.
	TextArrayOptions *TextArrayOptions `type:"structure"`

	// Options for text field. Present if IndexFieldType specifies the field is
	// of type text. A text field is always searchable. All options are enabled
	// by default.
	TextOptions *TextOptions `type:"structure"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *IndexField) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "IndexField"}

	if s.IndexFieldName == nil {
		invalidParams.Add(aws.NewErrParamRequired("IndexFieldName"))
	}
	if s.IndexFieldName != nil && len(*s.IndexFieldName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("IndexFieldName", 1))
	}
	if len(s.IndexFieldType) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("IndexFieldType"))
	}
	if s.DateOptions != nil {
		if err := s.DateOptions.Validate(); err != nil {
			invalidParams.AddNested("DateOptions", err.(aws.ErrInvalidParams))
		}
	}
	if s.DoubleOptions != nil {
		if err := s.DoubleOptions.Validate(); err != nil {
			invalidParams.AddNested("DoubleOptions", err.(aws.ErrInvalidParams))
		}
	}
	if s.IntOptions != nil {
		if err := s.IntOptions.Validate(); err != nil {
			invalidParams.AddNested("IntOptions", err.(aws.ErrInvalidParams))
		}
	}
	if s.LatLonOptions != nil {
		if err := s.LatLonOptions.Validate(); err != nil {
			invalidParams.AddNested("LatLonOptions", err.(aws.ErrInvalidParams))
		}
	}
	if s.LiteralOptions != nil {
		if err := s.LiteralOptions.Validate(); err != nil {
			invalidParams.AddNested("LiteralOptions", err.(aws.ErrInvalidParams))
		}
	}
	if s.TextOptions != nil {
		if err := s.TextOptions.Validate(); err != nil {
			invalidParams.AddNested("TextOptions", err.(aws.ErrInvalidParams))
		}
	}

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

// The value of an IndexField and its current status.
type IndexFieldStatus struct {
	_ struct{} `type:"structure"`

	// Configuration information for a field in the index, including its name, type,
	// and options. The supported options depend on the IndexFieldType.
	//
	// Options is a required field
	Options *IndexField `type:"structure" required:"true"`

	// The status of domain configuration option.
	//
	// Status is a required field
	Status *OptionStatus `type:"structure" required:"true"`
}

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

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

// Options for a field that contains an array of 64-bit signed integers. Present
// if IndexFieldType specifies the field is of type int-array. All options are
// enabled by default.
type IntArrayOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *int64 `type:"long"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// A list of source fields to map to the field.
	SourceFields *string `type:"string"`
}

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

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

// Options for a 64-bit signed integer field. Present if IndexFieldType specifies
// the field is of type int. All options are enabled by default.
type IntOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	// This can be important if you are using the field in an expression and that
	// field is not present in every document.
	DefaultValue *int64 `type:"long"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// Whether the field can be used to sort the search results.
	SortEnabled *bool `type:"boolean"`

	// The name of the source field to map to the field.
	SourceField *string `min:"1" type:"string"`
}

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

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

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

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

// Options for a latlon field. A latlon field contains a location stored as
// a latitude and longitude value pair. Present if IndexFieldType specifies
// the field is of type latlon. All options are enabled by default.
type LatLonOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *string `type:"string"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// Whether the field can be used to sort the search results.
	SortEnabled *bool `type:"boolean"`

	// A string that represents the name of an index field. CloudSearch supports
	// regular index fields as well as dynamic fields. A dynamic field's name defines
	// a pattern that begins or ends with a wildcard. Any document fields that don't
	// map to a regular index field but do match a dynamic field's pattern are configured
	// with the dynamic field's indexing options.
	//
	// Regular field names begin with a letter and can contain the following characters:
	// a-z (lowercase), 0-9, and _ (underscore). Dynamic field names must begin
	// or end with a wildcard (*). The wildcard can also be the only character in
	// a dynamic field name. Multiple wildcards, and wildcards embedded within a
	// string are not supported.
	//
	// The name score is reserved and cannot be used as a field name. To reference
	// a document's ID, you can use the name _id.
	SourceField *string `min:"1" type:"string"`
}

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

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

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

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

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

	// MaximumPartitionCount is a required field
	MaximumPartitionCount *int64 `min:"1" type:"integer" required:"true"`

	// MaximumReplicationCount is a required field
	MaximumReplicationCount *int64 `min:"1" type:"integer" required:"true"`
}

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

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

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

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

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

// The result of a ListDomainNames request. Contains a list of the domains owned
// by an account.
type ListDomainNamesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The names of the search domains owned by an account.
	DomainNames map[string]string `type:"map"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListDomainNamesOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Options for a field that contains an array of literal strings. Present if
// IndexFieldType specifies the field is of type literal-array. All options
// are enabled by default.
type LiteralArrayOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *string `type:"string"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// A list of source fields to map to the field.
	SourceFields *string `type:"string"`
}

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

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

// Options for literal field. Present if IndexFieldType specifies the field
// is of type literal. All options are enabled by default.
type LiteralOptions struct {
	_ struct{} `type:"structure"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *string `type:"string"`

	// Whether facet information can be returned for the field.
	FacetEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the contents of the field are searchable.
	SearchEnabled *bool `type:"boolean"`

	// Whether the field can be used to sort the search results.
	SortEnabled *bool `type:"boolean"`

	// A string that represents the name of an index field. CloudSearch supports
	// regular index fields as well as dynamic fields. A dynamic field's name defines
	// a pattern that begins or ends with a wildcard. Any document fields that don't
	// map to a regular index field but do match a dynamic field's pattern are configured
	// with the dynamic field's indexing options.
	//
	// Regular field names begin with a letter and can contain the following characters:
	// a-z (lowercase), 0-9, and _ (underscore). Dynamic field names must begin
	// or end with a wildcard (*). The wildcard can also be the only character in
	// a dynamic field name. Multiple wildcards, and wildcards embedded within a
	// string are not supported.
	//
	// The name score is reserved and cannot be used as a field name. To reference
	// a document's ID, you can use the name _id.
	SourceField *string `min:"1" type:"string"`
}

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

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

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

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

// The status of domain configuration option.
type OptionStatus struct {
	_ struct{} `type:"structure"`

	// A timestamp for when this option was created.
	//
	// CreationDate is a required field
	CreationDate *time.Time `type:"timestamp" timestampFormat:"iso8601" required:"true"`

	// Indicates that the option will be deleted once processing is complete.
	PendingDeletion *bool `type:"boolean"`

	// The state of processing a change to an option. Possible values:
	//
	//    * RequiresIndexDocuments: the option's latest value will not be deployed
	//    until IndexDocuments has been called and indexing is complete.
	//    * Processing: the option's latest value is in the process of being activated.
	//
	//    * Active: the option's latest value is completely deployed.
	//    * FailedToValidate: the option value is not compatible with the domain's
	//    data and cannot be used to index the data. You must either modify the
	//    option value or update or remove the incompatible documents.
	//
	// State is a required field
	State OptionState `type:"string" required:"true" enum:"true"`

	// A timestamp for when this option was last updated.
	//
	// UpdateDate is a required field
	UpdateDate *time.Time `type:"timestamp" timestampFormat:"iso8601" required:"true"`

	// A unique integer that indicates when this option was last updated.
	UpdateVersion *int64 `type:"integer"`
}

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

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

// The desired instance type and desired number of replicas of each index partition.
type ScalingParameters struct {
	_ struct{} `type:"structure"`

	// The instance type that you want to preconfigure for your domain. For example,
	// search.m1.small.
	DesiredInstanceType PartitionInstanceType `type:"string" enum:"true"`

	// The number of partitions you want to preconfigure for your domain. Only valid
	// when you select m2.2xlarge as the desired instance type.
	DesiredPartitionCount *int64 `type:"integer"`

	// The number of replicas you want to preconfigure for each index partition.
	DesiredReplicationCount *int64 `type:"integer"`
}

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

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

// The status and configuration of a search domain's scaling parameters.
type ScalingParametersStatus struct {
	_ struct{} `type:"structure"`

	// The desired instance type and desired number of replicas of each index partition.
	//
	// Options is a required field
	Options *ScalingParameters `type:"structure" required:"true"`

	// The status of domain configuration option.
	//
	// Status is a required field
	Status *OptionStatus `type:"structure" required:"true"`
}

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

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

// The endpoint to which service requests can be submitted.
type ServiceEndpoint struct {
	_ struct{} `type:"structure"`

	// The endpoint to which service requests can be submitted. For example, search-imdb-movies-oopcnjfn6ugofer3zx5iadxxca.eu-west-1.cloudsearch.amazonaws.com
	// or doc-imdb-movies-oopcnjfn6ugofer3zx5iadxxca.eu-west-1.cloudsearch.amazonaws.com.
	Endpoint *string `type:"string"`
}

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

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

// Configuration information for a search suggester. Each suggester has a unique
// name and specifies the text field you want to use for suggestions. The following
// options can be configured for a suggester: FuzzyMatching, SortExpression.
type Suggester struct {
	_ struct{} `type:"structure"`

	// Options for a search suggester.
	//
	// DocumentSuggesterOptions is a required field
	DocumentSuggesterOptions *DocumentSuggesterOptions `type:"structure" required:"true"`

	// Names must begin with a letter and can contain the following characters:
	// a-z (lowercase), 0-9, and _ (underscore).
	//
	// SuggesterName is a required field
	SuggesterName *string `min:"1" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *Suggester) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Suggester"}

	if s.DocumentSuggesterOptions == nil {
		invalidParams.Add(aws.NewErrParamRequired("DocumentSuggesterOptions"))
	}

	if s.SuggesterName == nil {
		invalidParams.Add(aws.NewErrParamRequired("SuggesterName"))
	}
	if s.SuggesterName != nil && len(*s.SuggesterName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SuggesterName", 1))
	}
	if s.DocumentSuggesterOptions != nil {
		if err := s.DocumentSuggesterOptions.Validate(); err != nil {
			invalidParams.AddNested("DocumentSuggesterOptions", err.(aws.ErrInvalidParams))
		}
	}

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

// The value of a Suggester and its current status.
type SuggesterStatus struct {
	_ struct{} `type:"structure"`

	// Configuration information for a search suggester. Each suggester has a unique
	// name and specifies the text field you want to use for suggestions. The following
	// options can be configured for a suggester: FuzzyMatching, SortExpression.
	//
	// Options is a required field
	Options *Suggester `type:"structure" required:"true"`

	// The status of domain configuration option.
	//
	// Status is a required field
	Status *OptionStatus `type:"structure" required:"true"`
}

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

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

// Options for a field that contains an array of text strings. Present if IndexFieldType
// specifies the field is of type text-array. A text-array field is always searchable.
// All options are enabled by default.
type TextArrayOptions struct {
	_ struct{} `type:"structure"`

	// The name of an analysis scheme for a text-array field.
	AnalysisScheme *string `type:"string"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *string `type:"string"`

	// Whether highlights can be returned for the field.
	HighlightEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// A list of source fields to map to the field.
	SourceFields *string `type:"string"`
}

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

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

// Options for text field. Present if IndexFieldType specifies the field is
// of type text. A text field is always searchable. All options are enabled
// by default.
type TextOptions struct {
	_ struct{} `type:"structure"`

	// The name of an analysis scheme for a text field.
	AnalysisScheme *string `type:"string"`

	// A value to use for the field if the field isn't specified for a document.
	DefaultValue *string `type:"string"`

	// Whether highlights can be returned for the field.
	HighlightEnabled *bool `type:"boolean"`

	// Whether the contents of the field can be returned in the search results.
	ReturnEnabled *bool `type:"boolean"`

	// Whether the field can be used to sort the search results.
	SortEnabled *bool `type:"boolean"`

	// A string that represents the name of an index field. CloudSearch supports
	// regular index fields as well as dynamic fields. A dynamic field's name defines
	// a pattern that begins or ends with a wildcard. Any document fields that don't
	// map to a regular index field but do match a dynamic field's pattern are configured
	// with the dynamic field's indexing options.
	//
	// Regular field names begin with a letter and can contain the following characters:
	// a-z (lowercase), 0-9, and _ (underscore). Dynamic field names must begin
	// or end with a wildcard (*). The wildcard can also be the only character in
	// a dynamic field name. Multiple wildcards, and wildcards embedded within a
	// string are not supported.
	//
	// The name score is reserved and cannot be used as a field name. To reference
	// a document's ID, you can use the name _id.
	SourceField *string `min:"1" type:"string"`
}

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

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

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

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

// Container for the parameters to the UpdateAvailabilityOptions operation.
// Specifies the name of the domain you want to update and the Multi-AZ availability
// option.
type UpdateAvailabilityOptionsInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// You expand an existing search domain to a second Availability Zone by setting
	// the Multi-AZ option to true. Similarly, you can turn off the Multi-AZ option
	// to downgrade the domain to a single Availability Zone by setting the Multi-AZ
	// option to false.
	//
	// MultiAZ is a required field
	MultiAZ *bool `type:"boolean" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateAvailabilityOptionsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateAvailabilityOptionsInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

	if s.MultiAZ == nil {
		invalidParams.Add(aws.NewErrParamRequired("MultiAZ"))
	}

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

// The result of a UpdateAvailabilityOptions request. Contains the status of
// the domain's availability options.
type UpdateAvailabilityOptionsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The newly-configured availability options. Indicates whether Multi-AZ is
	// enabled for the domain.
	AvailabilityOptions *AvailabilityOptionsStatus `type:"structure"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateAvailabilityOptionsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the UpdateScalingParameters operation. Specifies
// the name of the domain you want to update and the scaling parameters you
// want to configure.
type UpdateScalingParametersInput struct {
	_ struct{} `type:"structure"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`

	// The desired instance type and desired number of replicas of each index partition.
	//
	// ScalingParameters is a required field
	ScalingParameters *ScalingParameters `type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateScalingParametersInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateScalingParametersInput"}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

	if s.ScalingParameters == nil {
		invalidParams.Add(aws.NewErrParamRequired("ScalingParameters"))
	}

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

// The result of a UpdateScalingParameters request. Contains the status of the
// newly-configured scaling parameters.
type UpdateScalingParametersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The status and configuration of a search domain's scaling parameters.
	//
	// ScalingParameters is a required field
	ScalingParameters *ScalingParametersStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateScalingParametersOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Container for the parameters to the UpdateServiceAccessPolicies operation.
// Specifies the name of the domain you want to update and the access rules
// you want to configure.
type UpdateServiceAccessPoliciesInput struct {
	_ struct{} `type:"structure"`

	// The access rules you want to configure. These rules replace any existing
	// rules.
	//
	// AccessPolicies is a required field
	AccessPolicies *string `type:"string" required:"true"`

	// A string that represents the name of a domain. Domain names are unique across
	// the domains owned by an account within an AWS region. Domain names start
	// with a letter or number and can contain the following characters: a-z (lowercase),
	// 0-9, and - (hyphen).
	//
	// DomainName is a required field
	DomainName *string `min:"3" type:"string" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateServiceAccessPoliciesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateServiceAccessPoliciesInput"}

	if s.AccessPolicies == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccessPolicies"))
	}

	if s.DomainName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DomainName"))
	}
	if s.DomainName != nil && len(*s.DomainName) < 3 {
		invalidParams.Add(aws.NewErrParamMinLen("DomainName", 3))
	}

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

// The result of an UpdateServiceAccessPolicies request. Contains the new access
// policies.
type UpdateServiceAccessPoliciesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The access rules configured for the domain.
	//
	// AccessPolicies is a required field
	AccessPolicies *AccessPoliciesStatus `type:"structure" required:"true"`
}

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

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

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateServiceAccessPoliciesOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

type AlgorithmicStemming string

// Enum values for AlgorithmicStemming
const (
	AlgorithmicStemmingNone    AlgorithmicStemming = "none"
	AlgorithmicStemmingMinimal AlgorithmicStemming = "minimal"
	AlgorithmicStemmingLight   AlgorithmicStemming = "light"
	AlgorithmicStemmingFull    AlgorithmicStemming = "full"
)

func (enum AlgorithmicStemming) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AlgorithmicStemming) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// An IETF RFC 4646 (http://tools.ietf.org/html/rfc4646) language code or mul
// for multiple languages.
type AnalysisSchemeLanguage string

// Enum values for AnalysisSchemeLanguage
const (
	AnalysisSchemeLanguageAr     AnalysisSchemeLanguage = "ar"
	AnalysisSchemeLanguageBg     AnalysisSchemeLanguage = "bg"
	AnalysisSchemeLanguageCa     AnalysisSchemeLanguage = "ca"
	AnalysisSchemeLanguageCs     AnalysisSchemeLanguage = "cs"
	AnalysisSchemeLanguageDa     AnalysisSchemeLanguage = "da"
	AnalysisSchemeLanguageDe     AnalysisSchemeLanguage = "de"
	AnalysisSchemeLanguageEl     AnalysisSchemeLanguage = "el"
	AnalysisSchemeLanguageEn     AnalysisSchemeLanguage = "en"
	AnalysisSchemeLanguageEs     AnalysisSchemeLanguage = "es"
	AnalysisSchemeLanguageEu     AnalysisSchemeLanguage = "eu"
	AnalysisSchemeLanguageFa     AnalysisSchemeLanguage = "fa"
	AnalysisSchemeLanguageFi     AnalysisSchemeLanguage = "fi"
	AnalysisSchemeLanguageFr     AnalysisSchemeLanguage = "fr"
	AnalysisSchemeLanguageGa     AnalysisSchemeLanguage = "ga"
	AnalysisSchemeLanguageGl     AnalysisSchemeLanguage = "gl"
	AnalysisSchemeLanguageHe     AnalysisSchemeLanguage = "he"
	AnalysisSchemeLanguageHi     AnalysisSchemeLanguage = "hi"
	AnalysisSchemeLanguageHu     AnalysisSchemeLanguage = "hu"
	AnalysisSchemeLanguageHy     AnalysisSchemeLanguage = "hy"
	AnalysisSchemeLanguageId     AnalysisSchemeLanguage = "id"
	AnalysisSchemeLanguageIt     AnalysisSchemeLanguage = "it"
	AnalysisSchemeLanguageJa     AnalysisSchemeLanguage = "ja"
	AnalysisSchemeLanguageKo     AnalysisSchemeLanguage = "ko"
	AnalysisSchemeLanguageLv     AnalysisSchemeLanguage = "lv"
	AnalysisSchemeLanguageMul    AnalysisSchemeLanguage = "mul"
	AnalysisSchemeLanguageNl     AnalysisSchemeLanguage = "nl"
	AnalysisSchemeLanguageNo     AnalysisSchemeLanguage = "no"
	AnalysisSchemeLanguagePt     AnalysisSchemeLanguage = "pt"
	AnalysisSchemeLanguageRo     AnalysisSchemeLanguage = "ro"
	AnalysisSchemeLanguageRu     AnalysisSchemeLanguage = "ru"
	AnalysisSchemeLanguageSv     AnalysisSchemeLanguage = "sv"
	AnalysisSchemeLanguageTh     AnalysisSchemeLanguage = "th"
	AnalysisSchemeLanguageTr     AnalysisSchemeLanguage = "tr"
	AnalysisSchemeLanguageZhHans AnalysisSchemeLanguage = "zh-Hans"
	AnalysisSchemeLanguageZhHant AnalysisSchemeLanguage = "zh-Hant"
)

func (enum AnalysisSchemeLanguage) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AnalysisSchemeLanguage) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The type of field. The valid options for a field depend on the field type.
// For more information about the supported field types, see Configuring Index
// Fields (http://docs.aws.amazon.com/cloudsearch/latest/developerguide/configuring-index-fields.html)
// in the Amazon CloudSearch Developer Guide.
type IndexFieldType string

// Enum values for IndexFieldType
const (
	IndexFieldTypeInt          IndexFieldType = "int"
	IndexFieldTypeDouble       IndexFieldType = "double"
	IndexFieldTypeLiteral      IndexFieldType = "literal"
	IndexFieldTypeText         IndexFieldType = "text"
	IndexFieldTypeDate         IndexFieldType = "date"
	IndexFieldTypeLatlon       IndexFieldType = "latlon"
	IndexFieldTypeIntArray     IndexFieldType = "int-array"
	IndexFieldTypeDoubleArray  IndexFieldType = "double-array"
	IndexFieldTypeLiteralArray IndexFieldType = "literal-array"
	IndexFieldTypeTextArray    IndexFieldType = "text-array"
	IndexFieldTypeDateArray    IndexFieldType = "date-array"
)

func (enum IndexFieldType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum IndexFieldType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The state of processing a change to an option. One of:
//
//    * RequiresIndexDocuments: The option's latest value will not be deployed
//    until IndexDocuments has been called and indexing is complete.
//    * Processing: The option's latest value is in the process of being activated.
//
//    * Active: The option's latest value is fully deployed.
//    * FailedToValidate: The option value is not compatible with the domain's
//    data and cannot be used to index the data. You must either modify the
//    option value or update or remove the incompatible documents.
type OptionState string

// Enum values for OptionState
const (
	OptionStateRequiresIndexDocuments OptionState = "RequiresIndexDocuments"
	OptionStateProcessing             OptionState = "Processing"
	OptionStateActive                 OptionState = "Active"
	OptionStateFailedToValidate       OptionState = "FailedToValidate"
)

func (enum OptionState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OptionState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The instance type (such as search.m1.small) on which an index partition is
// hosted.
type PartitionInstanceType string

// Enum values for PartitionInstanceType
const (
	PartitionInstanceTypeSearchM1Small   PartitionInstanceType = "search.m1.small"
	PartitionInstanceTypeSearchM1Large   PartitionInstanceType = "search.m1.large"
	PartitionInstanceTypeSearchM2Xlarge  PartitionInstanceType = "search.m2.xlarge"
	PartitionInstanceTypeSearchM22xlarge PartitionInstanceType = "search.m2.2xlarge"
	PartitionInstanceTypeSearchM3Medium  PartitionInstanceType = "search.m3.medium"
	PartitionInstanceTypeSearchM3Large   PartitionInstanceType = "search.m3.large"
	PartitionInstanceTypeSearchM3Xlarge  PartitionInstanceType = "search.m3.xlarge"
	PartitionInstanceTypeSearchM32xlarge PartitionInstanceType = "search.m3.2xlarge"
)

func (enum PartitionInstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PartitionInstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SuggesterFuzzyMatching string

// Enum values for SuggesterFuzzyMatching
const (
	SuggesterFuzzyMatchingNone SuggesterFuzzyMatching = "none"
	SuggesterFuzzyMatchingLow  SuggesterFuzzyMatching = "low"
	SuggesterFuzzyMatchingHigh SuggesterFuzzyMatching = "high"
)

func (enum SuggesterFuzzyMatching) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SuggesterFuzzyMatching) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}