tile38/vendor/github.com/aws/aws-sdk-go/service/route53domains/api.go

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

package route53domains

import (
	"fmt"
	"time"

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

const opCheckDomainAvailability = "CheckDomainAvailability"

// CheckDomainAvailabilityRequest generates a "aws/request.Request" representing the
// client's request for the CheckDomainAvailability operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CheckDomainAvailability for more information on using the CheckDomainAvailability
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CheckDomainAvailabilityRequest method.
//    req, resp := client.CheckDomainAvailabilityRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/CheckDomainAvailability
func (c *Route53Domains) CheckDomainAvailabilityRequest(input *CheckDomainAvailabilityInput) (req *request.Request, output *CheckDomainAvailabilityOutput) {
	op := &request.Operation{
		Name:       opCheckDomainAvailability,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CheckDomainAvailabilityInput{}
	}

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

// CheckDomainAvailability API operation for Amazon Route 53 Domains.
//
// This operation checks the availability of one domain name. Note that if the
// availability status of a domain is pending, you must submit another request
// to determine the availability of the domain name.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation CheckDomainAvailability for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/CheckDomainAvailability
func (c *Route53Domains) CheckDomainAvailability(input *CheckDomainAvailabilityInput) (*CheckDomainAvailabilityOutput, error) {
	req, out := c.CheckDomainAvailabilityRequest(input)
	return out, req.Send()
}

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

const opCheckDomainTransferability = "CheckDomainTransferability"

// CheckDomainTransferabilityRequest generates a "aws/request.Request" representing the
// client's request for the CheckDomainTransferability operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CheckDomainTransferability for more information on using the CheckDomainTransferability
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the CheckDomainTransferabilityRequest method.
//    req, resp := client.CheckDomainTransferabilityRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/CheckDomainTransferability
func (c *Route53Domains) CheckDomainTransferabilityRequest(input *CheckDomainTransferabilityInput) (req *request.Request, output *CheckDomainTransferabilityOutput) {
	op := &request.Operation{
		Name:       opCheckDomainTransferability,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CheckDomainTransferabilityInput{}
	}

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

// CheckDomainTransferability API operation for Amazon Route 53 Domains.
//
// Checks whether a domain name can be transferred to Amazon Route 53.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation CheckDomainTransferability for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/CheckDomainTransferability
func (c *Route53Domains) CheckDomainTransferability(input *CheckDomainTransferabilityInput) (*CheckDomainTransferabilityOutput, error) {
	req, out := c.CheckDomainTransferabilityRequest(input)
	return out, req.Send()
}

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

const opDeleteTagsForDomain = "DeleteTagsForDomain"

// DeleteTagsForDomainRequest generates a "aws/request.Request" representing the
// client's request for the DeleteTagsForDomain operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteTagsForDomain for more information on using the DeleteTagsForDomain
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DeleteTagsForDomainRequest method.
//    req, resp := client.DeleteTagsForDomainRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DeleteTagsForDomain
func (c *Route53Domains) DeleteTagsForDomainRequest(input *DeleteTagsForDomainInput) (req *request.Request, output *DeleteTagsForDomainOutput) {
	op := &request.Operation{
		Name:       opDeleteTagsForDomain,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteTagsForDomainInput{}
	}

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

// DeleteTagsForDomain API operation for Amazon Route 53 Domains.
//
// This operation deletes the specified tags for a domain.
//
// All tag operations are eventually consistent; subsequent operations might
// not immediately represent all issued operations.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation DeleteTagsForDomain for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DeleteTagsForDomain
func (c *Route53Domains) DeleteTagsForDomain(input *DeleteTagsForDomainInput) (*DeleteTagsForDomainOutput, error) {
	req, out := c.DeleteTagsForDomainRequest(input)
	return out, req.Send()
}

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

const opDisableDomainAutoRenew = "DisableDomainAutoRenew"

// DisableDomainAutoRenewRequest generates a "aws/request.Request" representing the
// client's request for the DisableDomainAutoRenew operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DisableDomainAutoRenew for more information on using the DisableDomainAutoRenew
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DisableDomainAutoRenewRequest method.
//    req, resp := client.DisableDomainAutoRenewRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DisableDomainAutoRenew
func (c *Route53Domains) DisableDomainAutoRenewRequest(input *DisableDomainAutoRenewInput) (req *request.Request, output *DisableDomainAutoRenewOutput) {
	op := &request.Operation{
		Name:       opDisableDomainAutoRenew,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisableDomainAutoRenewInput{}
	}

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

// DisableDomainAutoRenew API operation for Amazon Route 53 Domains.
//
// This operation disables automatic renewal of domain registration for the
// specified domain.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation DisableDomainAutoRenew for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DisableDomainAutoRenew
func (c *Route53Domains) DisableDomainAutoRenew(input *DisableDomainAutoRenewInput) (*DisableDomainAutoRenewOutput, error) {
	req, out := c.DisableDomainAutoRenewRequest(input)
	return out, req.Send()
}

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

const opDisableDomainTransferLock = "DisableDomainTransferLock"

// DisableDomainTransferLockRequest generates a "aws/request.Request" representing the
// client's request for the DisableDomainTransferLock operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DisableDomainTransferLock for more information on using the DisableDomainTransferLock
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DisableDomainTransferLockRequest method.
//    req, resp := client.DisableDomainTransferLockRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DisableDomainTransferLock
func (c *Route53Domains) DisableDomainTransferLockRequest(input *DisableDomainTransferLockInput) (req *request.Request, output *DisableDomainTransferLockOutput) {
	op := &request.Operation{
		Name:       opDisableDomainTransferLock,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisableDomainTransferLockInput{}
	}

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

// DisableDomainTransferLock API operation for Amazon Route 53 Domains.
//
// This operation removes the transfer lock on the domain (specifically the
// clientTransferProhibited status) to allow domain transfers. We recommend
// you refrain from performing this action unless you intend to transfer the
// domain to a different registrar. Successful submission returns an operation
// ID that you can use to track the progress and completion of the action. If
// the request is not completed successfully, the domain registrant will be
// notified by email.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation DisableDomainTransferLock for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeDuplicateRequest "DuplicateRequest"
//   The request is already in progress for the domain.
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DisableDomainTransferLock
func (c *Route53Domains) DisableDomainTransferLock(input *DisableDomainTransferLockInput) (*DisableDomainTransferLockOutput, error) {
	req, out := c.DisableDomainTransferLockRequest(input)
	return out, req.Send()
}

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

const opEnableDomainAutoRenew = "EnableDomainAutoRenew"

// EnableDomainAutoRenewRequest generates a "aws/request.Request" representing the
// client's request for the EnableDomainAutoRenew operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See EnableDomainAutoRenew for more information on using the EnableDomainAutoRenew
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the EnableDomainAutoRenewRequest method.
//    req, resp := client.EnableDomainAutoRenewRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/EnableDomainAutoRenew
func (c *Route53Domains) EnableDomainAutoRenewRequest(input *EnableDomainAutoRenewInput) (req *request.Request, output *EnableDomainAutoRenewOutput) {
	op := &request.Operation{
		Name:       opEnableDomainAutoRenew,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &EnableDomainAutoRenewInput{}
	}

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

// EnableDomainAutoRenew API operation for Amazon Route 53 Domains.
//
// This operation configures Amazon Route 53 to automatically renew the specified
// domain before the domain registration expires. The cost of renewing your
// domain registration is billed to your AWS account.
//
// The period during which you can renew a domain name varies by TLD. For a
// list of TLDs and their renewal policies, see "Renewal, restoration, and deletion
// times" (http://wiki.gandi.net/en/domains/renew#renewal_restoration_and_deletion_times)
// on the website for our registrar partner, Gandi. Route 53 requires that you
// renew before the end of the renewal period that is listed on the Gandi website
// so we can complete processing before the deadline.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation EnableDomainAutoRenew for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/EnableDomainAutoRenew
func (c *Route53Domains) EnableDomainAutoRenew(input *EnableDomainAutoRenewInput) (*EnableDomainAutoRenewOutput, error) {
	req, out := c.EnableDomainAutoRenewRequest(input)
	return out, req.Send()
}

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

const opEnableDomainTransferLock = "EnableDomainTransferLock"

// EnableDomainTransferLockRequest generates a "aws/request.Request" representing the
// client's request for the EnableDomainTransferLock operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See EnableDomainTransferLock for more information on using the EnableDomainTransferLock
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the EnableDomainTransferLockRequest method.
//    req, resp := client.EnableDomainTransferLockRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/EnableDomainTransferLock
func (c *Route53Domains) EnableDomainTransferLockRequest(input *EnableDomainTransferLockInput) (req *request.Request, output *EnableDomainTransferLockOutput) {
	op := &request.Operation{
		Name:       opEnableDomainTransferLock,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &EnableDomainTransferLockInput{}
	}

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

// EnableDomainTransferLock API operation for Amazon Route 53 Domains.
//
// This operation sets the transfer lock on the domain (specifically the clientTransferProhibited
// status) to prevent domain transfers. Successful submission returns an operation
// ID that you can use to track the progress and completion of the action. If
// the request is not completed successfully, the domain registrant will be
// notified by email.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation EnableDomainTransferLock for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeDuplicateRequest "DuplicateRequest"
//   The request is already in progress for the domain.
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/EnableDomainTransferLock
func (c *Route53Domains) EnableDomainTransferLock(input *EnableDomainTransferLockInput) (*EnableDomainTransferLockOutput, error) {
	req, out := c.EnableDomainTransferLockRequest(input)
	return out, req.Send()
}

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

const opGetContactReachabilityStatus = "GetContactReachabilityStatus"

// GetContactReachabilityStatusRequest generates a "aws/request.Request" representing the
// client's request for the GetContactReachabilityStatus operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetContactReachabilityStatus for more information on using the GetContactReachabilityStatus
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the GetContactReachabilityStatusRequest method.
//    req, resp := client.GetContactReachabilityStatusRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetContactReachabilityStatus
func (c *Route53Domains) GetContactReachabilityStatusRequest(input *GetContactReachabilityStatusInput) (req *request.Request, output *GetContactReachabilityStatusOutput) {
	op := &request.Operation{
		Name:       opGetContactReachabilityStatus,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetContactReachabilityStatusInput{}
	}

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

// GetContactReachabilityStatus API operation for Amazon Route 53 Domains.
//
// For operations that require confirmation that the email address for the registrant
// contact is valid, such as registering a new domain, this operation returns
// information about whether the registrant contact has responded.
//
// If you want us to resend the email, use the ResendContactReachabilityEmail
// operation.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation GetContactReachabilityStatus for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetContactReachabilityStatus
func (c *Route53Domains) GetContactReachabilityStatus(input *GetContactReachabilityStatusInput) (*GetContactReachabilityStatusOutput, error) {
	req, out := c.GetContactReachabilityStatusRequest(input)
	return out, req.Send()
}

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

const opGetDomainDetail = "GetDomainDetail"

// GetDomainDetailRequest generates a "aws/request.Request" representing the
// client's request for the GetDomainDetail operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetDomainDetail for more information on using the GetDomainDetail
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the GetDomainDetailRequest method.
//    req, resp := client.GetDomainDetailRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetDomainDetail
func (c *Route53Domains) GetDomainDetailRequest(input *GetDomainDetailInput) (req *request.Request, output *GetDomainDetailOutput) {
	op := &request.Operation{
		Name:       opGetDomainDetail,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetDomainDetailInput{}
	}

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

// GetDomainDetail API operation for Amazon Route 53 Domains.
//
// This operation returns detailed information about a specified domain that
// is associated with the current AWS account. Contact information for the domain
// is also returned as part of the output.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation GetDomainDetail for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetDomainDetail
func (c *Route53Domains) GetDomainDetail(input *GetDomainDetailInput) (*GetDomainDetailOutput, error) {
	req, out := c.GetDomainDetailRequest(input)
	return out, req.Send()
}

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

const opGetDomainSuggestions = "GetDomainSuggestions"

// GetDomainSuggestionsRequest generates a "aws/request.Request" representing the
// client's request for the GetDomainSuggestions operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetDomainSuggestions for more information on using the GetDomainSuggestions
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the GetDomainSuggestionsRequest method.
//    req, resp := client.GetDomainSuggestionsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetDomainSuggestions
func (c *Route53Domains) GetDomainSuggestionsRequest(input *GetDomainSuggestionsInput) (req *request.Request, output *GetDomainSuggestionsOutput) {
	op := &request.Operation{
		Name:       opGetDomainSuggestions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetDomainSuggestionsInput{}
	}

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

// GetDomainSuggestions API operation for Amazon Route 53 Domains.
//
// The GetDomainSuggestions operation returns a list of suggested domain names
// given a string, which can either be a domain name or simply a word or phrase
// (without spaces).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation GetDomainSuggestions for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetDomainSuggestions
func (c *Route53Domains) GetDomainSuggestions(input *GetDomainSuggestionsInput) (*GetDomainSuggestionsOutput, error) {
	req, out := c.GetDomainSuggestionsRequest(input)
	return out, req.Send()
}

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

const opGetOperationDetail = "GetOperationDetail"

// GetOperationDetailRequest generates a "aws/request.Request" representing the
// client's request for the GetOperationDetail operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetOperationDetail for more information on using the GetOperationDetail
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the GetOperationDetailRequest method.
//    req, resp := client.GetOperationDetailRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetOperationDetail
func (c *Route53Domains) GetOperationDetailRequest(input *GetOperationDetailInput) (req *request.Request, output *GetOperationDetailOutput) {
	op := &request.Operation{
		Name:       opGetOperationDetail,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetOperationDetailInput{}
	}

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

// GetOperationDetail API operation for Amazon Route 53 Domains.
//
// This operation returns the current status of an operation that is not completed.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation GetOperationDetail for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetOperationDetail
func (c *Route53Domains) GetOperationDetail(input *GetOperationDetailInput) (*GetOperationDetailOutput, error) {
	req, out := c.GetOperationDetailRequest(input)
	return out, req.Send()
}

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

const opListDomains = "ListDomains"

// ListDomainsRequest generates a "aws/request.Request" representing the
// client's request for the ListDomains operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListDomains for more information on using the ListDomains
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListDomainsRequest method.
//    req, resp := client.ListDomainsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListDomains
func (c *Route53Domains) ListDomainsRequest(input *ListDomainsInput) (req *request.Request, output *ListDomainsOutput) {
	op := &request.Operation{
		Name:       opListDomains,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"Marker"},
			OutputTokens:    []string{"NextPageMarker"},
			LimitToken:      "MaxItems",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListDomainsInput{}
	}

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

// ListDomains API operation for Amazon Route 53 Domains.
//
// This operation returns all the domain names registered with Amazon Route
// 53 for the current AWS account.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation ListDomains for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListDomains
func (c *Route53Domains) ListDomains(input *ListDomainsInput) (*ListDomainsOutput, error) {
	req, out := c.ListDomainsRequest(input)
	return out, req.Send()
}

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

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

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

	cont := true
	for p.Next() && cont {
		cont = fn(p.Page().(*ListDomainsOutput), !p.HasNextPage())
	}
	return p.Err()
}

const opListOperations = "ListOperations"

// ListOperationsRequest generates a "aws/request.Request" representing the
// client's request for the ListOperations operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListOperations for more information on using the ListOperations
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListOperationsRequest method.
//    req, resp := client.ListOperationsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListOperations
func (c *Route53Domains) ListOperationsRequest(input *ListOperationsInput) (req *request.Request, output *ListOperationsOutput) {
	op := &request.Operation{
		Name:       opListOperations,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"Marker"},
			OutputTokens:    []string{"NextPageMarker"},
			LimitToken:      "MaxItems",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListOperationsInput{}
	}

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

// ListOperations API operation for Amazon Route 53 Domains.
//
// This operation returns the operation IDs of operations that are not yet complete.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation ListOperations for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListOperations
func (c *Route53Domains) ListOperations(input *ListOperationsInput) (*ListOperationsOutput, error) {
	req, out := c.ListOperationsRequest(input)
	return out, req.Send()
}

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

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

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

	cont := true
	for p.Next() && cont {
		cont = fn(p.Page().(*ListOperationsOutput), !p.HasNextPage())
	}
	return p.Err()
}

const opListTagsForDomain = "ListTagsForDomain"

// ListTagsForDomainRequest generates a "aws/request.Request" representing the
// client's request for the ListTagsForDomain operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListTagsForDomain for more information on using the ListTagsForDomain
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListTagsForDomainRequest method.
//    req, resp := client.ListTagsForDomainRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListTagsForDomain
func (c *Route53Domains) ListTagsForDomainRequest(input *ListTagsForDomainInput) (req *request.Request, output *ListTagsForDomainOutput) {
	op := &request.Operation{
		Name:       opListTagsForDomain,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListTagsForDomainInput{}
	}

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

// ListTagsForDomain API operation for Amazon Route 53 Domains.
//
// This operation returns all of the tags that are associated with the specified
// domain.
//
// All tag operations are eventually consistent; subsequent operations might
// not immediately represent all issued operations.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation ListTagsForDomain for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListTagsForDomain
func (c *Route53Domains) ListTagsForDomain(input *ListTagsForDomainInput) (*ListTagsForDomainOutput, error) {
	req, out := c.ListTagsForDomainRequest(input)
	return out, req.Send()
}

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

const opRegisterDomain = "RegisterDomain"

// RegisterDomainRequest generates a "aws/request.Request" representing the
// client's request for the RegisterDomain operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See RegisterDomain for more information on using the RegisterDomain
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the RegisterDomainRequest method.
//    req, resp := client.RegisterDomainRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RegisterDomain
func (c *Route53Domains) RegisterDomainRequest(input *RegisterDomainInput) (req *request.Request, output *RegisterDomainOutput) {
	op := &request.Operation{
		Name:       opRegisterDomain,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RegisterDomainInput{}
	}

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

// RegisterDomain API operation for Amazon Route 53 Domains.
//
// This operation registers a domain. Domains are registered by the AWS registrar
// partner, Gandi. For some top-level domains (TLDs), this operation requires
// extra parameters.
//
// When you register a domain, Amazon Route 53 does the following:
//
//    * Creates a Amazon Route 53 hosted zone that has the same name as the
//    domain. Amazon Route 53 assigns four name servers to your hosted zone
//    and automatically updates your domain registration with the names of these
//    name servers.
//
//    * Enables autorenew, so your domain registration will renew automatically
//    each year. We'll notify you in advance of the renewal date so you can
//    choose whether to renew the registration.
//
//    * Optionally enables privacy protection, so WHOIS queries return contact
//    information for our registrar partner, Gandi, instead of the information
//    you entered for registrant, admin, and tech contacts.
//
//    * If registration is successful, returns an operation ID that you can
//    use to track the progress and completion of the action. If the request
//    is not completed successfully, the domain registrant is notified by email.
//
//    * Charges your AWS account an amount based on the top-level domain. For
//    more information, see Amazon Route 53 Pricing (http://aws.amazon.com/route53/pricing/).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation RegisterDomain for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
//   * ErrCodeDuplicateRequest "DuplicateRequest"
//   The request is already in progress for the domain.
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
//   * ErrCodeDomainLimitExceeded "DomainLimitExceeded"
//   The number of domains has exceeded the allowed threshold for the account.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RegisterDomain
func (c *Route53Domains) RegisterDomain(input *RegisterDomainInput) (*RegisterDomainOutput, error) {
	req, out := c.RegisterDomainRequest(input)
	return out, req.Send()
}

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

const opRenewDomain = "RenewDomain"

// RenewDomainRequest generates a "aws/request.Request" representing the
// client's request for the RenewDomain operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See RenewDomain for more information on using the RenewDomain
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the RenewDomainRequest method.
//    req, resp := client.RenewDomainRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RenewDomain
func (c *Route53Domains) RenewDomainRequest(input *RenewDomainInput) (req *request.Request, output *RenewDomainOutput) {
	op := &request.Operation{
		Name:       opRenewDomain,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RenewDomainInput{}
	}

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

// RenewDomain API operation for Amazon Route 53 Domains.
//
// This operation renews a domain for the specified number of years. The cost
// of renewing your domain is billed to your AWS account.
//
// We recommend that you renew your domain several weeks before the expiration
// date. Some TLD registries delete domains before the expiration date if you
// haven't renewed far enough in advance. For more information about renewing
// domain registration, see Renewing Registration for a Domain (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/domain-renew.html)
// in the Amazon Route 53 Developer Guide.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation RenewDomain for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
//   * ErrCodeDuplicateRequest "DuplicateRequest"
//   The request is already in progress for the domain.
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RenewDomain
func (c *Route53Domains) RenewDomain(input *RenewDomainInput) (*RenewDomainOutput, error) {
	req, out := c.RenewDomainRequest(input)
	return out, req.Send()
}

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

const opResendContactReachabilityEmail = "ResendContactReachabilityEmail"

// ResendContactReachabilityEmailRequest generates a "aws/request.Request" representing the
// client's request for the ResendContactReachabilityEmail operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ResendContactReachabilityEmail for more information on using the ResendContactReachabilityEmail
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ResendContactReachabilityEmailRequest method.
//    req, resp := client.ResendContactReachabilityEmailRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ResendContactReachabilityEmail
func (c *Route53Domains) ResendContactReachabilityEmailRequest(input *ResendContactReachabilityEmailInput) (req *request.Request, output *ResendContactReachabilityEmailOutput) {
	op := &request.Operation{
		Name:       opResendContactReachabilityEmail,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ResendContactReachabilityEmailInput{}
	}

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

// ResendContactReachabilityEmail API operation for Amazon Route 53 Domains.
//
// For operations that require confirmation that the email address for the registrant
// contact is valid, such as registering a new domain, this operation resends
// the confirmation email to the current email address for the registrant contact.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation ResendContactReachabilityEmail for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ResendContactReachabilityEmail
func (c *Route53Domains) ResendContactReachabilityEmail(input *ResendContactReachabilityEmailInput) (*ResendContactReachabilityEmailOutput, error) {
	req, out := c.ResendContactReachabilityEmailRequest(input)
	return out, req.Send()
}

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

const opRetrieveDomainAuthCode = "RetrieveDomainAuthCode"

// RetrieveDomainAuthCodeRequest generates a "aws/request.Request" representing the
// client's request for the RetrieveDomainAuthCode operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See RetrieveDomainAuthCode for more information on using the RetrieveDomainAuthCode
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the RetrieveDomainAuthCodeRequest method.
//    req, resp := client.RetrieveDomainAuthCodeRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RetrieveDomainAuthCode
func (c *Route53Domains) RetrieveDomainAuthCodeRequest(input *RetrieveDomainAuthCodeInput) (req *request.Request, output *RetrieveDomainAuthCodeOutput) {
	op := &request.Operation{
		Name:       opRetrieveDomainAuthCode,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RetrieveDomainAuthCodeInput{}
	}

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

// RetrieveDomainAuthCode API operation for Amazon Route 53 Domains.
//
// This operation returns the AuthCode for the domain. To transfer a domain
// to another registrar, you provide this value to the new registrar.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation RetrieveDomainAuthCode for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RetrieveDomainAuthCode
func (c *Route53Domains) RetrieveDomainAuthCode(input *RetrieveDomainAuthCodeInput) (*RetrieveDomainAuthCodeOutput, error) {
	req, out := c.RetrieveDomainAuthCodeRequest(input)
	return out, req.Send()
}

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

const opTransferDomain = "TransferDomain"

// TransferDomainRequest generates a "aws/request.Request" representing the
// client's request for the TransferDomain operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See TransferDomain for more information on using the TransferDomain
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the TransferDomainRequest method.
//    req, resp := client.TransferDomainRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/TransferDomain
func (c *Route53Domains) TransferDomainRequest(input *TransferDomainInput) (req *request.Request, output *TransferDomainOutput) {
	op := &request.Operation{
		Name:       opTransferDomain,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &TransferDomainInput{}
	}

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

// TransferDomain API operation for Amazon Route 53 Domains.
//
// This operation transfers a domain from another registrar to Amazon Route
// 53. When the transfer is complete, the domain is registered with the AWS
// registrar partner, Gandi.
//
// For transfer requirements, a detailed procedure, and information about viewing
// the status of a domain transfer, see Transferring Registration for a Domain
// to Amazon Route 53 (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/domain-transfer-to-route-53.html)
// in the Amazon Route 53 Developer Guide.
//
// If the registrar for your domain is also the DNS service provider for the
// domain, we highly recommend that you consider transferring your DNS service
// to Amazon Route 53 or to another DNS service provider before you transfer
// your registration. Some registrars provide free DNS service when you purchase
// a domain registration. When you transfer the registration, the previous registrar
// will not renew your domain registration and could end your DNS service at
// any time.
//
// If the registrar for your domain is also the DNS service provider for the
// domain and you don't transfer DNS service to another provider, your website,
// email, and the web applications associated with the domain might become unavailable.
//
// If the transfer is successful, this method returns an operation ID that you
// can use to track the progress and completion of the action. If the transfer
// doesn't complete successfully, the domain registrant will be notified by
// email.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation TransferDomain for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
//   * ErrCodeDuplicateRequest "DuplicateRequest"
//   The request is already in progress for the domain.
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
//   * ErrCodeDomainLimitExceeded "DomainLimitExceeded"
//   The number of domains has exceeded the allowed threshold for the account.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/TransferDomain
func (c *Route53Domains) TransferDomain(input *TransferDomainInput) (*TransferDomainOutput, error) {
	req, out := c.TransferDomainRequest(input)
	return out, req.Send()
}

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

const opUpdateDomainContact = "UpdateDomainContact"

// UpdateDomainContactRequest generates a "aws/request.Request" representing the
// client's request for the UpdateDomainContact operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateDomainContact for more information on using the UpdateDomainContact
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateDomainContactRequest method.
//    req, resp := client.UpdateDomainContactRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainContact
func (c *Route53Domains) UpdateDomainContactRequest(input *UpdateDomainContactInput) (req *request.Request, output *UpdateDomainContactOutput) {
	op := &request.Operation{
		Name:       opUpdateDomainContact,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateDomainContactInput{}
	}

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

// UpdateDomainContact API operation for Amazon Route 53 Domains.
//
// This operation updates the contact information for a particular domain. Information
// for at least one contact (registrant, administrator, or technical) must be
// supplied for update.
//
// If the update is successful, this method returns an operation ID that you
// can use to track the progress and completion of the action. If the request
// is not completed successfully, the domain registrant will be notified by
// email.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation UpdateDomainContact for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeDuplicateRequest "DuplicateRequest"
//   The request is already in progress for the domain.
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainContact
func (c *Route53Domains) UpdateDomainContact(input *UpdateDomainContactInput) (*UpdateDomainContactOutput, error) {
	req, out := c.UpdateDomainContactRequest(input)
	return out, req.Send()
}

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

const opUpdateDomainContactPrivacy = "UpdateDomainContactPrivacy"

// UpdateDomainContactPrivacyRequest generates a "aws/request.Request" representing the
// client's request for the UpdateDomainContactPrivacy operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateDomainContactPrivacy for more information on using the UpdateDomainContactPrivacy
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateDomainContactPrivacyRequest method.
//    req, resp := client.UpdateDomainContactPrivacyRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainContactPrivacy
func (c *Route53Domains) UpdateDomainContactPrivacyRequest(input *UpdateDomainContactPrivacyInput) (req *request.Request, output *UpdateDomainContactPrivacyOutput) {
	op := &request.Operation{
		Name:       opUpdateDomainContactPrivacy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateDomainContactPrivacyInput{}
	}

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

// UpdateDomainContactPrivacy API operation for Amazon Route 53 Domains.
//
// This operation updates the specified domain contact's privacy setting. When
// the privacy option is enabled, personal information such as postal or email
// address is hidden from the results of a public WHOIS query. The privacy services
// are provided by the AWS registrar, Gandi. For more information, see the Gandi
// privacy features (http://www.gandi.net/domain/whois/?currency=USD&lang=en).
//
// This operation only affects the privacy of the specified contact type (registrant,
// administrator, or tech). Successful acceptance returns an operation ID that
// you can use with GetOperationDetail to track the progress and completion
// of the action. If the request is not completed successfully, the domain registrant
// will be notified by email.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation UpdateDomainContactPrivacy for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeDuplicateRequest "DuplicateRequest"
//   The request is already in progress for the domain.
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainContactPrivacy
func (c *Route53Domains) UpdateDomainContactPrivacy(input *UpdateDomainContactPrivacyInput) (*UpdateDomainContactPrivacyOutput, error) {
	req, out := c.UpdateDomainContactPrivacyRequest(input)
	return out, req.Send()
}

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

const opUpdateDomainNameservers = "UpdateDomainNameservers"

// UpdateDomainNameserversRequest generates a "aws/request.Request" representing the
// client's request for the UpdateDomainNameservers operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateDomainNameservers for more information on using the UpdateDomainNameservers
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateDomainNameserversRequest method.
//    req, resp := client.UpdateDomainNameserversRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainNameservers
func (c *Route53Domains) UpdateDomainNameserversRequest(input *UpdateDomainNameserversInput) (req *request.Request, output *UpdateDomainNameserversOutput) {
	op := &request.Operation{
		Name:       opUpdateDomainNameservers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateDomainNameserversInput{}
	}

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

// UpdateDomainNameservers API operation for Amazon Route 53 Domains.
//
// This operation replaces the current set of name servers for the domain with
// the specified set of name servers. If you use Amazon Route 53 as your DNS
// service, specify the four name servers in the delegation set for the hosted
// zone for the domain.
//
// If successful, this operation returns an operation ID that you can use to
// track the progress and completion of the action. If the request is not completed
// successfully, the domain registrant will be notified by email.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation UpdateDomainNameservers for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeDuplicateRequest "DuplicateRequest"
//   The request is already in progress for the domain.
//
//   * ErrCodeTLDRulesViolation "TLDRulesViolation"
//   The top-level domain does not support this operation.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainNameservers
func (c *Route53Domains) UpdateDomainNameservers(input *UpdateDomainNameserversInput) (*UpdateDomainNameserversOutput, error) {
	req, out := c.UpdateDomainNameserversRequest(input)
	return out, req.Send()
}

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

const opUpdateTagsForDomain = "UpdateTagsForDomain"

// UpdateTagsForDomainRequest generates a "aws/request.Request" representing the
// client's request for the UpdateTagsForDomain operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateTagsForDomain for more information on using the UpdateTagsForDomain
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the UpdateTagsForDomainRequest method.
//    req, resp := client.UpdateTagsForDomainRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateTagsForDomain
func (c *Route53Domains) UpdateTagsForDomainRequest(input *UpdateTagsForDomainInput) (req *request.Request, output *UpdateTagsForDomainOutput) {
	op := &request.Operation{
		Name:       opUpdateTagsForDomain,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateTagsForDomainInput{}
	}

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

// UpdateTagsForDomain API operation for Amazon Route 53 Domains.
//
// This operation adds or updates tags for a specified domain.
//
// All tag operations are eventually consistent; subsequent operations might
// not immediately represent all issued operations.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation UpdateTagsForDomain for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
//   * ErrCodeOperationLimitExceeded "OperationLimitExceeded"
//   The number of operations or jobs running exceeded the allowed threshold for
//   the account.
//
//   * ErrCodeUnsupportedTLD "UnsupportedTLD"
//   Amazon Route 53 does not support this top-level domain (TLD).
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateTagsForDomain
func (c *Route53Domains) UpdateTagsForDomain(input *UpdateTagsForDomainInput) (*UpdateTagsForDomainOutput, error) {
	req, out := c.UpdateTagsForDomainRequest(input)
	return out, req.Send()
}

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

const opViewBilling = "ViewBilling"

// ViewBillingRequest generates a "aws/request.Request" representing the
// client's request for the ViewBilling operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ViewBilling for more information on using the ViewBilling
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ViewBillingRequest method.
//    req, resp := client.ViewBillingRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ViewBilling
func (c *Route53Domains) ViewBillingRequest(input *ViewBillingInput) (req *request.Request, output *ViewBillingOutput) {
	op := &request.Operation{
		Name:       opViewBilling,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ViewBillingInput{}
	}

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

// ViewBilling API operation for Amazon Route 53 Domains.
//
// Returns all the domain-related billing records for the current AWS account
// for a specified period
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Route 53 Domains's
// API operation ViewBilling for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidInput "InvalidInput"
//   The requested item is not acceptable. For example, for an OperationId it
//   might refer to the ID of an operation that is already completed. For a domain
//   name, it might not be a valid domain name or belong to the requester account.
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ViewBilling
func (c *Route53Domains) ViewBilling(input *ViewBillingInput) (*ViewBillingOutput, error) {
	req, out := c.ViewBillingRequest(input)
	return out, req.Send()
}

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

// Information for one billing record.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/BillingRecord
type BillingRecord struct {
	_ struct{} `type:"structure"`

	// The date that the operation was billed, in Unix format.
	BillDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The name of the domain that the billing record applies to. If the domain
	// name contains characters other than a-z, 0-9, and - (hyphen), such as an
	// internationalized domain name, then this value is in Punycode. For more information,
	// see DNS Domain Name Format (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DomainNameFormat.html)
	// in the Amazon Route 53 Developer Guidezzz.
	DomainName *string `type:"string"`

	// The ID of the invoice that is associated with the billing record.
	InvoiceId *string `type:"string"`

	// The operation that you were charged for.
	Operation *string `type:"string" enum:"OperationType"`

	// The price that you were charged for the operation, in US dollars.
	//
	// Example value: 12.0
	Price *float64 `type:"double"`
}

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

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

// SetBillDate sets the BillDate field's value.
func (s *BillingRecord) SetBillDate(v time.Time) *BillingRecord {
	s.BillDate = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *BillingRecord) SetDomainName(v string) *BillingRecord {
	s.DomainName = &v
	return s
}

// SetInvoiceId sets the InvoiceId field's value.
func (s *BillingRecord) SetInvoiceId(v string) *BillingRecord {
	s.InvoiceId = &v
	return s
}

// SetOperation sets the Operation field's value.
func (s *BillingRecord) SetOperation(v string) *BillingRecord {
	s.Operation = &v
	return s
}

// SetPrice sets the Price field's value.
func (s *BillingRecord) SetPrice(v float64) *BillingRecord {
	s.Price = &v
	return s
}

// The CheckDomainAvailability request contains the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/CheckDomainAvailabilityRequest
type CheckDomainAvailabilityInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain that you want to get availability for.
	//
	// Constraints: The domain name can contain only the letters a through z, the
	// numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not
	// supported.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// Reserved for future use.
	IdnLangCode *string `type:"string"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *CheckDomainAvailabilityInput) SetDomainName(v string) *CheckDomainAvailabilityInput {
	s.DomainName = &v
	return s
}

// SetIdnLangCode sets the IdnLangCode field's value.
func (s *CheckDomainAvailabilityInput) SetIdnLangCode(v string) *CheckDomainAvailabilityInput {
	s.IdnLangCode = &v
	return s
}

// The CheckDomainAvailability response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/CheckDomainAvailabilityResponse
type CheckDomainAvailabilityOutput struct {
	_ struct{} `type:"structure"`

	// Whether the domain name is available for registering.
	//
	// You can register only domains designated as AVAILABLE.
	//
	// Valid values:
	//
	// AVAILABLEThe domain name is available.
	//
	// AVAILABLE_RESERVEDThe domain name is reserved under specific conditions.
	//
	// AVAILABLE_PREORDERThe domain name is available and can be preordered.
	//
	// DONT_KNOWThe TLD registry didn't reply with a definitive answer about whether
	// the domain name is available. Amazon Route 53 can return this response for
	// a variety of reasons, for example, the registry is performing maintenance.
	// Try again later.
	//
	// PENDINGThe TLD registry didn't return a response in the expected amount of
	// time. When the response is delayed, it usually takes just a few extra seconds.
	// You can resubmit the request immediately.
	//
	// RESERVEDThe domain name has been reserved for another person or organization.
	//
	// UNAVAILABLEThe domain name is not available.
	//
	// UNAVAILABLE_PREMIUMThe domain name is not available.
	//
	// UNAVAILABLE_RESTRICTEDThe domain name is forbidden.
	//
	// Availability is a required field
	Availability *string `type:"string" required:"true" enum:"DomainAvailability"`
}

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

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

// SetAvailability sets the Availability field's value.
func (s *CheckDomainAvailabilityOutput) SetAvailability(v string) *CheckDomainAvailabilityOutput {
	s.Availability = &v
	return s
}

// The CheckDomainTransferability request contains the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/CheckDomainTransferabilityRequest
type CheckDomainTransferabilityInput struct {
	_ struct{} `type:"structure"`

	// If the registrar for the top-level domain (TLD) requires an authorization
	// code to transfer the domain, the code that you got from the current registrar
	// for the domain.
	AuthCode *string `type:"string"`

	// The name of the domain that you want to transfer to Amazon Route 53.
	//
	// Constraints: The domain name can contain only the letters a through z, the
	// numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not
	// supported.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetAuthCode sets the AuthCode field's value.
func (s *CheckDomainTransferabilityInput) SetAuthCode(v string) *CheckDomainTransferabilityInput {
	s.AuthCode = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *CheckDomainTransferabilityInput) SetDomainName(v string) *CheckDomainTransferabilityInput {
	s.DomainName = &v
	return s
}

// The CheckDomainTransferability response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/CheckDomainTransferabilityResponse
type CheckDomainTransferabilityOutput struct {
	_ struct{} `type:"structure"`

	// A complex type that contains information about whether the specified domain
	// can be transferred to Amazon Route 53.
	//
	// Transferability is a required field
	Transferability *DomainTransferability `type:"structure" required:"true"`
}

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

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

// SetTransferability sets the Transferability field's value.
func (s *CheckDomainTransferabilityOutput) SetTransferability(v *DomainTransferability) *CheckDomainTransferabilityOutput {
	s.Transferability = v
	return s
}

// ContactDetail includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ContactDetail
type ContactDetail struct {
	_ struct{} `type:"structure"`

	// First line of the contact's address.
	AddressLine1 *string `type:"string"`

	// Second line of contact's address, if any.
	AddressLine2 *string `type:"string"`

	// The city of the contact's address.
	City *string `type:"string"`

	// Indicates whether the contact is a person, company, association, or public
	// organization. If you choose an option other than PERSON, you must enter an
	// organization name, and you can't enable privacy protection for the contact.
	ContactType *string `type:"string" enum:"ContactType"`

	// Code for the country of the contact's address.
	CountryCode *string `type:"string" enum:"CountryCode"`

	// Email address of the contact.
	Email *string `type:"string"`

	// A list of name-value pairs for parameters required by certain top-level domains.
	ExtraParams []*ExtraParam `type:"list"`

	// Fax number of the contact.
	//
	// Constraints: Phone number must be specified in the format "+[country dialing
	// code].[number including any area code]". For example, a US phone number might
	// appear as "+1.1234567890".
	Fax *string `type:"string"`

	// First name of contact.
	FirstName *string `type:"string"`

	// Last name of contact.
	LastName *string `type:"string"`

	// Name of the organization for contact types other than PERSON.
	OrganizationName *string `type:"string"`

	// The phone number of the contact.
	//
	// Constraints: Phone number must be specified in the format "+[country dialing
	// code].[number including any area code>]". For example, a US phone number
	// might appear as "+1.1234567890".
	PhoneNumber *string `type:"string"`

	// The state or province of the contact's city.
	State *string `type:"string"`

	// The zip or postal code of the contact's address.
	ZipCode *string `type:"string"`
}

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

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

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

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

// SetAddressLine1 sets the AddressLine1 field's value.
func (s *ContactDetail) SetAddressLine1(v string) *ContactDetail {
	s.AddressLine1 = &v
	return s
}

// SetAddressLine2 sets the AddressLine2 field's value.
func (s *ContactDetail) SetAddressLine2(v string) *ContactDetail {
	s.AddressLine2 = &v
	return s
}

// SetCity sets the City field's value.
func (s *ContactDetail) SetCity(v string) *ContactDetail {
	s.City = &v
	return s
}

// SetContactType sets the ContactType field's value.
func (s *ContactDetail) SetContactType(v string) *ContactDetail {
	s.ContactType = &v
	return s
}

// SetCountryCode sets the CountryCode field's value.
func (s *ContactDetail) SetCountryCode(v string) *ContactDetail {
	s.CountryCode = &v
	return s
}

// SetEmail sets the Email field's value.
func (s *ContactDetail) SetEmail(v string) *ContactDetail {
	s.Email = &v
	return s
}

// SetExtraParams sets the ExtraParams field's value.
func (s *ContactDetail) SetExtraParams(v []*ExtraParam) *ContactDetail {
	s.ExtraParams = v
	return s
}

// SetFax sets the Fax field's value.
func (s *ContactDetail) SetFax(v string) *ContactDetail {
	s.Fax = &v
	return s
}

// SetFirstName sets the FirstName field's value.
func (s *ContactDetail) SetFirstName(v string) *ContactDetail {
	s.FirstName = &v
	return s
}

// SetLastName sets the LastName field's value.
func (s *ContactDetail) SetLastName(v string) *ContactDetail {
	s.LastName = &v
	return s
}

// SetOrganizationName sets the OrganizationName field's value.
func (s *ContactDetail) SetOrganizationName(v string) *ContactDetail {
	s.OrganizationName = &v
	return s
}

// SetPhoneNumber sets the PhoneNumber field's value.
func (s *ContactDetail) SetPhoneNumber(v string) *ContactDetail {
	s.PhoneNumber = &v
	return s
}

// SetState sets the State field's value.
func (s *ContactDetail) SetState(v string) *ContactDetail {
	s.State = &v
	return s
}

// SetZipCode sets the ZipCode field's value.
func (s *ContactDetail) SetZipCode(v string) *ContactDetail {
	s.ZipCode = &v
	return s
}

// The DeleteTagsForDomainRequest includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DeleteTagsForDomainRequest
type DeleteTagsForDomainInput struct {
	_ struct{} `type:"structure"`

	// The domain for which you want to delete one or more tags.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// A list of tag keys to delete.
	//
	// TagsToDelete is a required field
	TagsToDelete []*string `type:"list" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *DeleteTagsForDomainInput) SetDomainName(v string) *DeleteTagsForDomainInput {
	s.DomainName = &v
	return s
}

// SetTagsToDelete sets the TagsToDelete field's value.
func (s *DeleteTagsForDomainInput) SetTagsToDelete(v []*string) *DeleteTagsForDomainInput {
	s.TagsToDelete = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DeleteTagsForDomainResponse
type DeleteTagsForDomainOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DisableDomainAutoRenewRequest
type DisableDomainAutoRenewInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain that you want to disable automatic renewal for.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *DisableDomainAutoRenewInput) SetDomainName(v string) *DisableDomainAutoRenewInput {
	s.DomainName = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DisableDomainAutoRenewResponse
type DisableDomainAutoRenewOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// The DisableDomainTransferLock request includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DisableDomainTransferLockRequest
type DisableDomainTransferLockInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain that you want to remove the transfer lock for.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *DisableDomainTransferLockInput) SetDomainName(v string) *DisableDomainTransferLockInput {
	s.DomainName = &v
	return s
}

// The DisableDomainTransferLock response includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DisableDomainTransferLockResponse
type DisableDomainTransferLockOutput struct {
	_ struct{} `type:"structure"`

	// Identifier for tracking the progress of the request. To use this ID to query
	// the operation status, use GetOperationDetail.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *DisableDomainTransferLockOutput) SetOperationId(v string) *DisableDomainTransferLockOutput {
	s.OperationId = &v
	return s
}

// Information about one suggested domain name.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DomainSuggestion
type DomainSuggestion struct {
	_ struct{} `type:"structure"`

	// Whether the domain name is available for registering.
	//
	// You can register only the domains that are designated as AVAILABLE.
	//
	// Valid values:
	//
	// AVAILABLEThe domain name is available.
	//
	// AVAILABLE_RESERVEDThe domain name is reserved under specific conditions.
	//
	// AVAILABLE_PREORDERThe domain name is available and can be preordered.
	//
	// DONT_KNOWThe TLD registry didn't reply with a definitive answer about whether
	// the domain name is available. Amazon Route 53 can return this response for
	// a variety of reasons, for example, the registry is performing maintenance.
	// Try again later.
	//
	// PENDINGThe TLD registry didn't return a response in the expected amount of
	// time. When the response is delayed, it usually takes just a few extra seconds.
	// You can resubmit the request immediately.
	//
	// RESERVEDThe domain name has been reserved for another person or organization.
	//
	// UNAVAILABLEThe domain name is not available.
	//
	// UNAVAILABLE_PREMIUMThe domain name is not available.
	//
	// UNAVAILABLE_RESTRICTEDThe domain name is forbidden.
	Availability *string `type:"string"`

	// A suggested domain name.
	DomainName *string `type:"string"`
}

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

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

// SetAvailability sets the Availability field's value.
func (s *DomainSuggestion) SetAvailability(v string) *DomainSuggestion {
	s.Availability = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *DomainSuggestion) SetDomainName(v string) *DomainSuggestion {
	s.DomainName = &v
	return s
}

// Summary information about one domain.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DomainSummary
type DomainSummary struct {
	_ struct{} `type:"structure"`

	// Indicates whether the domain is automatically renewed upon expiration.
	AutoRenew *bool `type:"boolean"`

	// The name of the domain that the summary information applies to.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// Expiration date of the domain in Coordinated Universal Time (UTC).
	Expiry *time.Time `type:"timestamp" timestampFormat:"unix"`

	// Indicates whether a domain is locked from unauthorized transfer to another
	// party.
	TransferLock *bool `type:"boolean"`
}

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

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

// SetAutoRenew sets the AutoRenew field's value.
func (s *DomainSummary) SetAutoRenew(v bool) *DomainSummary {
	s.AutoRenew = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *DomainSummary) SetDomainName(v string) *DomainSummary {
	s.DomainName = &v
	return s
}

// SetExpiry sets the Expiry field's value.
func (s *DomainSummary) SetExpiry(v time.Time) *DomainSummary {
	s.Expiry = &v
	return s
}

// SetTransferLock sets the TransferLock field's value.
func (s *DomainSummary) SetTransferLock(v bool) *DomainSummary {
	s.TransferLock = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/DomainTransferability
type DomainTransferability struct {
	_ struct{} `type:"structure"`

	// Whether the domain name can be transferred to Amazon Route 53.
	//
	// You can transfer only domains that have a value of TRANSFERABLE for Transferable.
	//
	// Valid values:
	//
	// TRANSFERABLEThe domain name can be transferred to Amazon Route 53.
	//
	// UNTRANSFERRABLEThe domain name can't be transferred to Amazon Route 53.
	//
	// DONT_KNOWReserved for future use.
	Transferable *string `type:"string" enum:"Transferable"`
}

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

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

// SetTransferable sets the Transferable field's value.
func (s *DomainTransferability) SetTransferable(v string) *DomainTransferability {
	s.Transferable = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/EnableDomainAutoRenewRequest
type EnableDomainAutoRenewInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain that you want to enable automatic renewal for.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *EnableDomainAutoRenewInput) SetDomainName(v string) *EnableDomainAutoRenewInput {
	s.DomainName = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/EnableDomainAutoRenewResponse
type EnableDomainAutoRenewOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// A request to set the transfer lock for the specified domain.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/EnableDomainTransferLockRequest
type EnableDomainTransferLockInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain that you want to set the transfer lock for.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *EnableDomainTransferLockInput) SetDomainName(v string) *EnableDomainTransferLockInput {
	s.DomainName = &v
	return s
}

// The EnableDomainTransferLock response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/EnableDomainTransferLockResponse
type EnableDomainTransferLockOutput struct {
	_ struct{} `type:"structure"`

	// Identifier for tracking the progress of the request. To use this ID to query
	// the operation status, use GetOperationDetail.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *EnableDomainTransferLockOutput) SetOperationId(v string) *EnableDomainTransferLockOutput {
	s.OperationId = &v
	return s
}

// ExtraParam includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ExtraParam
type ExtraParam struct {
	_ struct{} `type:"structure"`

	// Name of the additional parameter required by the top-level domain.
	//
	// Name is a required field
	Name *string `type:"string" required:"true" enum:"ExtraParamName"`

	// Values corresponding to the additional parameter names required by some top-level
	// domains.
	//
	// Value is a required field
	Value *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetContactReachabilityStatusRequest
type GetContactReachabilityStatusInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain for which you want to know whether the registrant
	// contact has confirmed that the email address is valid.
	DomainName *string `locationName:"domainName" type:"string"`
}

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

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

// SetDomainName sets the DomainName field's value.
func (s *GetContactReachabilityStatusInput) SetDomainName(v string) *GetContactReachabilityStatusInput {
	s.DomainName = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetContactReachabilityStatusResponse
type GetContactReachabilityStatusOutput struct {
	_ struct{} `type:"structure"`

	// The domain name for which you requested the reachability status.
	DomainName *string `locationName:"domainName" type:"string"`

	// Whether the registrant contact has responded. Values include the following:
	//
	// PENDINGWe sent the confirmation email and haven't received a response yet.
	//
	// DONEWe sent the email and got confirmation from the registrant contact.
	//
	// EXPIREDThe time limit expired before the registrant contact responded.
	Status *string `locationName:"status" type:"string" enum:"ReachabilityStatus"`
}

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

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

// SetDomainName sets the DomainName field's value.
func (s *GetContactReachabilityStatusOutput) SetDomainName(v string) *GetContactReachabilityStatusOutput {
	s.DomainName = &v
	return s
}

// SetStatus sets the Status field's value.
func (s *GetContactReachabilityStatusOutput) SetStatus(v string) *GetContactReachabilityStatusOutput {
	s.Status = &v
	return s
}

// The GetDomainDetail request includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetDomainDetailRequest
type GetDomainDetailInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain that you want to get detailed information about.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *GetDomainDetailInput) SetDomainName(v string) *GetDomainDetailInput {
	s.DomainName = &v
	return s
}

// The GetDomainDetail response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetDomainDetailResponse
type GetDomainDetailOutput struct {
	_ struct{} `type:"structure"`

	// Email address to contact to report incorrect contact information for a domain,
	// to report that the domain is being used to send spam, to report that someone
	// is cybersquatting on a domain name, or report some other type of abuse.
	AbuseContactEmail *string `type:"string"`

	// Phone number for reporting abuse.
	AbuseContactPhone *string `type:"string"`

	// Provides details about the domain administrative contact.
	//
	// AdminContact is a required field
	AdminContact *ContactDetail `type:"structure" required:"true"`

	// Specifies whether contact information for the admin contact is concealed
	// from WHOIS queries. If the value is true, WHOIS ("who is") queries will return
	// contact information for our registrar partner, Gandi, instead of the contact
	// information that you enter.
	AdminPrivacy *bool `type:"boolean"`

	// Specifies whether the domain registration is set to renew automatically.
	AutoRenew *bool `type:"boolean"`

	// The date when the domain was created as found in the response to a WHOIS
	// query. The date format is Unix time.
	CreationDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// Reserved for future use.
	DnsSec *string `type:"string"`

	// The name of a domain.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// The date when the registration for the domain is set to expire. The date
	// format is Unix time.
	ExpirationDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The name of the domain.
	//
	// Nameservers is a required field
	Nameservers []*Nameserver `type:"list" required:"true"`

	// Provides details about the domain registrant.
	//
	// RegistrantContact is a required field
	RegistrantContact *ContactDetail `type:"structure" required:"true"`

	// Specifies whether contact information for the registrant contact is concealed
	// from WHOIS queries. If the value is true, WHOIS ("who is") queries will return
	// contact information for our registrar partner, Gandi, instead of the contact
	// information that you enter.
	RegistrantPrivacy *bool `type:"boolean"`

	// Name of the registrar of the domain as identified in the registry. Amazon
	// Route 53 domains are registered by registrar Gandi. The value is "GANDI SAS".
	RegistrarName *string `type:"string"`

	// Web address of the registrar.
	RegistrarUrl *string `type:"string"`

	// Reserved for future use.
	RegistryDomainId *string `type:"string"`

	// Reseller of the domain. Domains registered or transferred using Amazon Route
	// 53 domains will have "Amazon" as the reseller.
	Reseller *string `type:"string"`

	// An array of domain name status codes, also known as Extensible Provisioning
	// Protocol (EPP) status codes.
	//
	// ICANN, the organization that maintains a central database of domain names,
	// has developed a set of domain name status codes that tell you the status
	// of a variety of operations on a domain name, for example, registering a domain
	// name, transferring a domain name to another registrar, renewing the registration
	// for a domain name, and so on. All registrars use this same set of status
	// codes.
	//
	// For a current list of domain name status codes and an explanation of what
	// each code means, go to the ICANN website (https://www.icann.org/) and search
	// for epp status codes. (Search on the ICANN website; web searches sometimes
	// return an old version of the document.)
	StatusList []*string `type:"list"`

	// Provides details about the domain technical contact.
	//
	// TechContact is a required field
	TechContact *ContactDetail `type:"structure" required:"true"`

	// Specifies whether contact information for the tech contact is concealed from
	// WHOIS queries. If the value is true, WHOIS ("who is") queries will return
	// contact information for our registrar partner, Gandi, instead of the contact
	// information that you enter.
	TechPrivacy *bool `type:"boolean"`

	// The last updated date of the domain as found in the response to a WHOIS query.
	// The date format is Unix time.
	UpdatedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The fully qualified name of the WHOIS server that can answer the WHOIS query
	// for the domain.
	WhoIsServer *string `type:"string"`
}

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

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

// SetAbuseContactEmail sets the AbuseContactEmail field's value.
func (s *GetDomainDetailOutput) SetAbuseContactEmail(v string) *GetDomainDetailOutput {
	s.AbuseContactEmail = &v
	return s
}

// SetAbuseContactPhone sets the AbuseContactPhone field's value.
func (s *GetDomainDetailOutput) SetAbuseContactPhone(v string) *GetDomainDetailOutput {
	s.AbuseContactPhone = &v
	return s
}

// SetAdminContact sets the AdminContact field's value.
func (s *GetDomainDetailOutput) SetAdminContact(v *ContactDetail) *GetDomainDetailOutput {
	s.AdminContact = v
	return s
}

// SetAdminPrivacy sets the AdminPrivacy field's value.
func (s *GetDomainDetailOutput) SetAdminPrivacy(v bool) *GetDomainDetailOutput {
	s.AdminPrivacy = &v
	return s
}

// SetAutoRenew sets the AutoRenew field's value.
func (s *GetDomainDetailOutput) SetAutoRenew(v bool) *GetDomainDetailOutput {
	s.AutoRenew = &v
	return s
}

// SetCreationDate sets the CreationDate field's value.
func (s *GetDomainDetailOutput) SetCreationDate(v time.Time) *GetDomainDetailOutput {
	s.CreationDate = &v
	return s
}

// SetDnsSec sets the DnsSec field's value.
func (s *GetDomainDetailOutput) SetDnsSec(v string) *GetDomainDetailOutput {
	s.DnsSec = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *GetDomainDetailOutput) SetDomainName(v string) *GetDomainDetailOutput {
	s.DomainName = &v
	return s
}

// SetExpirationDate sets the ExpirationDate field's value.
func (s *GetDomainDetailOutput) SetExpirationDate(v time.Time) *GetDomainDetailOutput {
	s.ExpirationDate = &v
	return s
}

// SetNameservers sets the Nameservers field's value.
func (s *GetDomainDetailOutput) SetNameservers(v []*Nameserver) *GetDomainDetailOutput {
	s.Nameservers = v
	return s
}

// SetRegistrantContact sets the RegistrantContact field's value.
func (s *GetDomainDetailOutput) SetRegistrantContact(v *ContactDetail) *GetDomainDetailOutput {
	s.RegistrantContact = v
	return s
}

// SetRegistrantPrivacy sets the RegistrantPrivacy field's value.
func (s *GetDomainDetailOutput) SetRegistrantPrivacy(v bool) *GetDomainDetailOutput {
	s.RegistrantPrivacy = &v
	return s
}

// SetRegistrarName sets the RegistrarName field's value.
func (s *GetDomainDetailOutput) SetRegistrarName(v string) *GetDomainDetailOutput {
	s.RegistrarName = &v
	return s
}

// SetRegistrarUrl sets the RegistrarUrl field's value.
func (s *GetDomainDetailOutput) SetRegistrarUrl(v string) *GetDomainDetailOutput {
	s.RegistrarUrl = &v
	return s
}

// SetRegistryDomainId sets the RegistryDomainId field's value.
func (s *GetDomainDetailOutput) SetRegistryDomainId(v string) *GetDomainDetailOutput {
	s.RegistryDomainId = &v
	return s
}

// SetReseller sets the Reseller field's value.
func (s *GetDomainDetailOutput) SetReseller(v string) *GetDomainDetailOutput {
	s.Reseller = &v
	return s
}

// SetStatusList sets the StatusList field's value.
func (s *GetDomainDetailOutput) SetStatusList(v []*string) *GetDomainDetailOutput {
	s.StatusList = v
	return s
}

// SetTechContact sets the TechContact field's value.
func (s *GetDomainDetailOutput) SetTechContact(v *ContactDetail) *GetDomainDetailOutput {
	s.TechContact = v
	return s
}

// SetTechPrivacy sets the TechPrivacy field's value.
func (s *GetDomainDetailOutput) SetTechPrivacy(v bool) *GetDomainDetailOutput {
	s.TechPrivacy = &v
	return s
}

// SetUpdatedDate sets the UpdatedDate field's value.
func (s *GetDomainDetailOutput) SetUpdatedDate(v time.Time) *GetDomainDetailOutput {
	s.UpdatedDate = &v
	return s
}

// SetWhoIsServer sets the WhoIsServer field's value.
func (s *GetDomainDetailOutput) SetWhoIsServer(v string) *GetDomainDetailOutput {
	s.WhoIsServer = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetDomainSuggestionsRequest
type GetDomainSuggestionsInput struct {
	_ struct{} `type:"structure"`

	// A domain name that you want to use as the basis for a list of possible domain
	// names. The domain name must contain a top-level domain (TLD), such as .com,
	// that Amazon Route 53 supports. For a list of TLDs, see Domains that You Can
	// Register with Amazon Route 53 (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar-tld-list.html)
	// in the Amazon Route 53 Developer Guide.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// If OnlyAvailable is true, Amazon Route 53 returns only domain names that
	// are available. If OnlyAvailable is false, Amazon Route 53 returns domain
	// names without checking whether they're available to be registered. To determine
	// whether the domain is available, you can call checkDomainAvailability for
	// each suggestion.
	//
	// OnlyAvailable is a required field
	OnlyAvailable *bool `type:"boolean" required:"true"`

	// The number of suggested domain names that you want Amazon Route 53 to return.
	//
	// SuggestionCount is a required field
	SuggestionCount *int64 `type:"integer" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *GetDomainSuggestionsInput) SetDomainName(v string) *GetDomainSuggestionsInput {
	s.DomainName = &v
	return s
}

// SetOnlyAvailable sets the OnlyAvailable field's value.
func (s *GetDomainSuggestionsInput) SetOnlyAvailable(v bool) *GetDomainSuggestionsInput {
	s.OnlyAvailable = &v
	return s
}

// SetSuggestionCount sets the SuggestionCount field's value.
func (s *GetDomainSuggestionsInput) SetSuggestionCount(v int64) *GetDomainSuggestionsInput {
	s.SuggestionCount = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetDomainSuggestionsResponse
type GetDomainSuggestionsOutput struct {
	_ struct{} `type:"structure"`

	// A list of possible domain names. If you specified true for OnlyAvailable
	// in the request, the list contains only domains that are available for registration.
	SuggestionsList []*DomainSuggestion `type:"list"`
}

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

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

// SetSuggestionsList sets the SuggestionsList field's value.
func (s *GetDomainSuggestionsOutput) SetSuggestionsList(v []*DomainSuggestion) *GetDomainSuggestionsOutput {
	s.SuggestionsList = v
	return s
}

// The GetOperationDetail request includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetOperationDetailRequest
type GetOperationDetailInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the operation for which you want to get the status. Amazon
	// Route 53 returned the identifier in the response to the original request.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

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

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

// SetOperationId sets the OperationId field's value.
func (s *GetOperationDetailInput) SetOperationId(v string) *GetOperationDetailInput {
	s.OperationId = &v
	return s
}

// The GetOperationDetail response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/GetOperationDetailResponse
type GetOperationDetailOutput struct {
	_ struct{} `type:"structure"`

	// The name of a domain.
	DomainName *string `type:"string"`

	// Detailed information on the status including possible errors.
	Message *string `type:"string"`

	// The identifier for the operation.
	OperationId *string `type:"string"`

	// The current status of the requested operation in the system.
	Status *string `type:"string" enum:"OperationStatus"`

	// The date when the request was submitted.
	SubmittedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The type of operation that was requested.
	Type *string `type:"string" enum:"OperationType"`
}

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

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

// SetDomainName sets the DomainName field's value.
func (s *GetOperationDetailOutput) SetDomainName(v string) *GetOperationDetailOutput {
	s.DomainName = &v
	return s
}

// SetMessage sets the Message field's value.
func (s *GetOperationDetailOutput) SetMessage(v string) *GetOperationDetailOutput {
	s.Message = &v
	return s
}

// SetOperationId sets the OperationId field's value.
func (s *GetOperationDetailOutput) SetOperationId(v string) *GetOperationDetailOutput {
	s.OperationId = &v
	return s
}

// SetStatus sets the Status field's value.
func (s *GetOperationDetailOutput) SetStatus(v string) *GetOperationDetailOutput {
	s.Status = &v
	return s
}

// SetSubmittedDate sets the SubmittedDate field's value.
func (s *GetOperationDetailOutput) SetSubmittedDate(v time.Time) *GetOperationDetailOutput {
	s.SubmittedDate = &v
	return s
}

// SetType sets the Type field's value.
func (s *GetOperationDetailOutput) SetType(v string) *GetOperationDetailOutput {
	s.Type = &v
	return s
}

// The ListDomains request includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListDomainsRequest
type ListDomainsInput struct {
	_ struct{} `type:"structure"`

	// For an initial request for a list of domains, omit this element. If the number
	// of domains that are associated with the current AWS account is greater than
	// the value that you specified for MaxItems, you can use Marker to return additional
	// domains. Get the value of NextPageMarker from the previous response, and
	// submit another request that includes the value of NextPageMarker in the Marker
	// element.
	//
	// Constraints: The marker must match the value specified in the previous request.
	Marker *string `type:"string"`

	// Number of domains to be returned.
	//
	// Default: 20
	MaxItems *int64 `type:"integer"`
}

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

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

// SetMarker sets the Marker field's value.
func (s *ListDomainsInput) SetMarker(v string) *ListDomainsInput {
	s.Marker = &v
	return s
}

// SetMaxItems sets the MaxItems field's value.
func (s *ListDomainsInput) SetMaxItems(v int64) *ListDomainsInput {
	s.MaxItems = &v
	return s
}

// The ListDomains response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListDomainsResponse
type ListDomainsOutput struct {
	_ struct{} `type:"structure"`

	// A summary of domains.
	//
	// Domains is a required field
	Domains []*DomainSummary `type:"list" required:"true"`

	// If there are more domains than you specified for MaxItems in the request,
	// submit another request and include the value of NextPageMarker in the value
	// of Marker.
	NextPageMarker *string `type:"string"`
}

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

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

// SetDomains sets the Domains field's value.
func (s *ListDomainsOutput) SetDomains(v []*DomainSummary) *ListDomainsOutput {
	s.Domains = v
	return s
}

// SetNextPageMarker sets the NextPageMarker field's value.
func (s *ListDomainsOutput) SetNextPageMarker(v string) *ListDomainsOutput {
	s.NextPageMarker = &v
	return s
}

// The ListOperations request includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListOperationsRequest
type ListOperationsInput struct {
	_ struct{} `type:"structure"`

	// For an initial request for a list of operations, omit this element. If the
	// number of operations that are not yet complete is greater than the value
	// that you specified for MaxItems, you can use Marker to return additional
	// operations. Get the value of NextPageMarker from the previous response, and
	// submit another request that includes the value of NextPageMarker in the Marker
	// element.
	Marker *string `type:"string"`

	// Number of domains to be returned.
	//
	// Default: 20
	MaxItems *int64 `type:"integer"`
}

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

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

// SetMarker sets the Marker field's value.
func (s *ListOperationsInput) SetMarker(v string) *ListOperationsInput {
	s.Marker = &v
	return s
}

// SetMaxItems sets the MaxItems field's value.
func (s *ListOperationsInput) SetMaxItems(v int64) *ListOperationsInput {
	s.MaxItems = &v
	return s
}

// The ListOperations response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListOperationsResponse
type ListOperationsOutput struct {
	_ struct{} `type:"structure"`

	// If there are more operations than you specified for MaxItems in the request,
	// submit another request and include the value of NextPageMarker in the value
	// of Marker.
	NextPageMarker *string `type:"string"`

	// Lists summaries of the operations.
	//
	// Operations is a required field
	Operations []*OperationSummary `type:"list" required:"true"`
}

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

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

// SetNextPageMarker sets the NextPageMarker field's value.
func (s *ListOperationsOutput) SetNextPageMarker(v string) *ListOperationsOutput {
	s.NextPageMarker = &v
	return s
}

// SetOperations sets the Operations field's value.
func (s *ListOperationsOutput) SetOperations(v []*OperationSummary) *ListOperationsOutput {
	s.Operations = v
	return s
}

// The ListTagsForDomainRequest includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListTagsForDomainRequest
type ListTagsForDomainInput struct {
	_ struct{} `type:"structure"`

	// The domain for which you want to get a list of tags.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *ListTagsForDomainInput) SetDomainName(v string) *ListTagsForDomainInput {
	s.DomainName = &v
	return s
}

// The ListTagsForDomain response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ListTagsForDomainResponse
type ListTagsForDomainOutput struct {
	_ struct{} `type:"structure"`

	// A list of the tags that are associated with the specified domain.
	//
	// TagList is a required field
	TagList []*Tag `type:"list" required:"true"`
}

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

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

// SetTagList sets the TagList field's value.
func (s *ListTagsForDomainOutput) SetTagList(v []*Tag) *ListTagsForDomainOutput {
	s.TagList = v
	return s
}

// Nameserver includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/Nameserver
type Nameserver struct {
	_ struct{} `type:"structure"`

	// Glue IP address of a name server entry. Glue IP addresses are required only
	// when the name of the name server is a subdomain of the domain. For example,
	// if your domain is example.com and the name server for the domain is ns.example.com,
	// you need to specify the IP address for ns.example.com.
	//
	// Constraints: The list can contain only one IPv4 and one IPv6 address.
	GlueIps []*string `type:"list"`

	// The fully qualified host name of the name server.
	//
	// Constraint: Maximum 255 characters
	//
	// Name is a required field
	Name *string `type:"string" required:"true"`
}

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

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

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

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

// SetGlueIps sets the GlueIps field's value.
func (s *Nameserver) SetGlueIps(v []*string) *Nameserver {
	s.GlueIps = v
	return s
}

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

// OperationSummary includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/OperationSummary
type OperationSummary struct {
	_ struct{} `type:"structure"`

	// Identifier returned to track the requested action.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`

	// The current status of the requested operation in the system.
	//
	// Status is a required field
	Status *string `type:"string" required:"true" enum:"OperationStatus"`

	// The date when the request was submitted.
	//
	// SubmittedDate is a required field
	SubmittedDate *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// Type of the action requested.
	//
	// Type is a required field
	Type *string `type:"string" required:"true" enum:"OperationType"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *OperationSummary) SetOperationId(v string) *OperationSummary {
	s.OperationId = &v
	return s
}

// SetStatus sets the Status field's value.
func (s *OperationSummary) SetStatus(v string) *OperationSummary {
	s.Status = &v
	return s
}

// SetSubmittedDate sets the SubmittedDate field's value.
func (s *OperationSummary) SetSubmittedDate(v time.Time) *OperationSummary {
	s.SubmittedDate = &v
	return s
}

// SetType sets the Type field's value.
func (s *OperationSummary) SetType(v string) *OperationSummary {
	s.Type = &v
	return s
}

// The RegisterDomain request includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RegisterDomainRequest
type RegisterDomainInput struct {
	_ struct{} `type:"structure"`

	// Provides detailed contact information.
	//
	// AdminContact is a required field
	AdminContact *ContactDetail `type:"structure" required:"true"`

	// Indicates whether the domain will be automatically renewed (true) or not
	// (false). Autorenewal only takes effect after the account is charged.
	//
	// Default: true
	AutoRenew *bool `type:"boolean"`

	// The domain name that you want to register.
	//
	// Constraints: The domain name can contain only the letters a through z, the
	// numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not
	// supported.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// The number of years that you want to register the domain for. Domains are
	// registered for a minimum of one year. The maximum period depends on the top-level
	// domain. For the range of valid values for your domain, see Domains that You
	// Can Register with Amazon Route 53 (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar-tld-list.html)
	// in the Amazon Route 53 Developer Guide.
	//
	// Default: 1
	//
	// DurationInYears is a required field
	DurationInYears *int64 `min:"1" type:"integer" required:"true"`

	// Reserved for future use.
	IdnLangCode *string `type:"string"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	//
	// Default: true
	PrivacyProtectAdminContact *bool `type:"boolean"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	//
	// Default: true
	PrivacyProtectRegistrantContact *bool `type:"boolean"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	//
	// Default: true
	PrivacyProtectTechContact *bool `type:"boolean"`

	// Provides detailed contact information.
	//
	// RegistrantContact is a required field
	RegistrantContact *ContactDetail `type:"structure" required:"true"`

	// Provides detailed contact information.
	//
	// TechContact is a required field
	TechContact *ContactDetail `type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *RegisterDomainInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "RegisterDomainInput"}
	if s.AdminContact == nil {
		invalidParams.Add(request.NewErrParamRequired("AdminContact"))
	}
	if s.DomainName == nil {
		invalidParams.Add(request.NewErrParamRequired("DomainName"))
	}
	if s.DurationInYears == nil {
		invalidParams.Add(request.NewErrParamRequired("DurationInYears"))
	}
	if s.DurationInYears != nil && *s.DurationInYears < 1 {
		invalidParams.Add(request.NewErrParamMinValue("DurationInYears", 1))
	}
	if s.RegistrantContact == nil {
		invalidParams.Add(request.NewErrParamRequired("RegistrantContact"))
	}
	if s.TechContact == nil {
		invalidParams.Add(request.NewErrParamRequired("TechContact"))
	}
	if s.AdminContact != nil {
		if err := s.AdminContact.Validate(); err != nil {
			invalidParams.AddNested("AdminContact", err.(request.ErrInvalidParams))
		}
	}
	if s.RegistrantContact != nil {
		if err := s.RegistrantContact.Validate(); err != nil {
			invalidParams.AddNested("RegistrantContact", err.(request.ErrInvalidParams))
		}
	}
	if s.TechContact != nil {
		if err := s.TechContact.Validate(); err != nil {
			invalidParams.AddNested("TechContact", err.(request.ErrInvalidParams))
		}
	}

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

// SetAdminContact sets the AdminContact field's value.
func (s *RegisterDomainInput) SetAdminContact(v *ContactDetail) *RegisterDomainInput {
	s.AdminContact = v
	return s
}

// SetAutoRenew sets the AutoRenew field's value.
func (s *RegisterDomainInput) SetAutoRenew(v bool) *RegisterDomainInput {
	s.AutoRenew = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *RegisterDomainInput) SetDomainName(v string) *RegisterDomainInput {
	s.DomainName = &v
	return s
}

// SetDurationInYears sets the DurationInYears field's value.
func (s *RegisterDomainInput) SetDurationInYears(v int64) *RegisterDomainInput {
	s.DurationInYears = &v
	return s
}

// SetIdnLangCode sets the IdnLangCode field's value.
func (s *RegisterDomainInput) SetIdnLangCode(v string) *RegisterDomainInput {
	s.IdnLangCode = &v
	return s
}

// SetPrivacyProtectAdminContact sets the PrivacyProtectAdminContact field's value.
func (s *RegisterDomainInput) SetPrivacyProtectAdminContact(v bool) *RegisterDomainInput {
	s.PrivacyProtectAdminContact = &v
	return s
}

// SetPrivacyProtectRegistrantContact sets the PrivacyProtectRegistrantContact field's value.
func (s *RegisterDomainInput) SetPrivacyProtectRegistrantContact(v bool) *RegisterDomainInput {
	s.PrivacyProtectRegistrantContact = &v
	return s
}

// SetPrivacyProtectTechContact sets the PrivacyProtectTechContact field's value.
func (s *RegisterDomainInput) SetPrivacyProtectTechContact(v bool) *RegisterDomainInput {
	s.PrivacyProtectTechContact = &v
	return s
}

// SetRegistrantContact sets the RegistrantContact field's value.
func (s *RegisterDomainInput) SetRegistrantContact(v *ContactDetail) *RegisterDomainInput {
	s.RegistrantContact = v
	return s
}

// SetTechContact sets the TechContact field's value.
func (s *RegisterDomainInput) SetTechContact(v *ContactDetail) *RegisterDomainInput {
	s.TechContact = v
	return s
}

// The RegisterDomain response includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RegisterDomainResponse
type RegisterDomainOutput struct {
	_ struct{} `type:"structure"`

	// Identifier for tracking the progress of the request. To use this ID to query
	// the operation status, use GetOperationDetail.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *RegisterDomainOutput) SetOperationId(v string) *RegisterDomainOutput {
	s.OperationId = &v
	return s
}

// A RenewDomain request includes the number of years that you want to renew
// for and the current expiration year.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RenewDomainRequest
type RenewDomainInput struct {
	_ struct{} `type:"structure"`

	// The year when the registration for the domain is set to expire. This value
	// must match the current expiration date for the domain.
	//
	// CurrentExpiryYear is a required field
	CurrentExpiryYear *int64 `type:"integer" required:"true"`

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

	// The number of years that you want to renew the domain for. The maximum number
	// of years depends on the top-level domain. For the range of valid values for
	// your domain, see Domains that You Can Register with Amazon Route 53 (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar-tld-list.html)
	// in the Amazon Route 53 Developer Guide.
	//
	// Default: 1
	DurationInYears *int64 `min:"1" type:"integer"`
}

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

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

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

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

// SetCurrentExpiryYear sets the CurrentExpiryYear field's value.
func (s *RenewDomainInput) SetCurrentExpiryYear(v int64) *RenewDomainInput {
	s.CurrentExpiryYear = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *RenewDomainInput) SetDomainName(v string) *RenewDomainInput {
	s.DomainName = &v
	return s
}

// SetDurationInYears sets the DurationInYears field's value.
func (s *RenewDomainInput) SetDurationInYears(v int64) *RenewDomainInput {
	s.DurationInYears = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RenewDomainResponse
type RenewDomainOutput struct {
	_ struct{} `type:"structure"`

	// The identifier for tracking the progress of the request. To use this ID to
	// query the operation status, use GetOperationDetail.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *RenewDomainOutput) SetOperationId(v string) *RenewDomainOutput {
	s.OperationId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ResendContactReachabilityEmailRequest
type ResendContactReachabilityEmailInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain for which you want Amazon Route 53 to resend a confirmation
	// email to the registrant contact.
	DomainName *string `locationName:"domainName" type:"string"`
}

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

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

// SetDomainName sets the DomainName field's value.
func (s *ResendContactReachabilityEmailInput) SetDomainName(v string) *ResendContactReachabilityEmailInput {
	s.DomainName = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ResendContactReachabilityEmailResponse
type ResendContactReachabilityEmailOutput struct {
	_ struct{} `type:"structure"`

	// The domain name for which you requested a confirmation email.
	DomainName *string `locationName:"domainName" type:"string"`

	// The email address for the registrant contact at the time that we sent the
	// verification email.
	EmailAddress *string `locationName:"emailAddress" type:"string"`

	// True if the email address for the registrant contact has already been verified,
	// and false otherwise. If the email address has already been verified, we don't
	// send another confirmation email.
	IsAlreadyVerified *bool `locationName:"isAlreadyVerified" type:"boolean"`
}

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

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

// SetDomainName sets the DomainName field's value.
func (s *ResendContactReachabilityEmailOutput) SetDomainName(v string) *ResendContactReachabilityEmailOutput {
	s.DomainName = &v
	return s
}

// SetEmailAddress sets the EmailAddress field's value.
func (s *ResendContactReachabilityEmailOutput) SetEmailAddress(v string) *ResendContactReachabilityEmailOutput {
	s.EmailAddress = &v
	return s
}

// SetIsAlreadyVerified sets the IsAlreadyVerified field's value.
func (s *ResendContactReachabilityEmailOutput) SetIsAlreadyVerified(v bool) *ResendContactReachabilityEmailOutput {
	s.IsAlreadyVerified = &v
	return s
}

// A request for the authorization code for the specified domain. To transfer
// a domain to another registrar, you provide this value to the new registrar.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RetrieveDomainAuthCodeRequest
type RetrieveDomainAuthCodeInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain that you want to get an authorization code for.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *RetrieveDomainAuthCodeInput) SetDomainName(v string) *RetrieveDomainAuthCodeInput {
	s.DomainName = &v
	return s
}

// The RetrieveDomainAuthCode response includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/RetrieveDomainAuthCodeResponse
type RetrieveDomainAuthCodeOutput struct {
	_ struct{} `type:"structure"`

	// The authorization code for the domain.
	//
	// AuthCode is a required field
	AuthCode *string `type:"string" required:"true"`
}

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

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

// SetAuthCode sets the AuthCode field's value.
func (s *RetrieveDomainAuthCodeOutput) SetAuthCode(v string) *RetrieveDomainAuthCodeOutput {
	s.AuthCode = &v
	return s
}

// Each tag includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/Tag
type Tag struct {
	_ struct{} `type:"structure"`

	// The key (name) of a tag.
	//
	// Valid values: A-Z, a-z, 0-9, space, ".:/=+\-@"
	//
	// Constraints: Each key can be 1-128 characters long.
	Key *string `type:"string"`

	// The value of a tag.
	//
	// Valid values: A-Z, a-z, 0-9, space, ".:/=+\-@"
	//
	// Constraints: Each value can be 0-256 characters long.
	Value *string `type:"string"`
}

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

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

// SetKey sets the Key field's value.
func (s *Tag) SetKey(v string) *Tag {
	s.Key = &v
	return s
}

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

// The TransferDomain request includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/TransferDomainRequest
type TransferDomainInput struct {
	_ struct{} `type:"structure"`

	// Provides detailed contact information.
	//
	// AdminContact is a required field
	AdminContact *ContactDetail `type:"structure" required:"true"`

	// The authorization code for the domain. You get this value from the current
	// registrar.
	AuthCode *string `type:"string"`

	// Indicates whether the domain will be automatically renewed (true) or not
	// (false). Autorenewal only takes effect after the account is charged.
	//
	// Default: true
	AutoRenew *bool `type:"boolean"`

	// The name of the domain that you want to transfer to Amazon Route 53.
	//
	// Constraints: The domain name can contain only the letters a through z, the
	// numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not
	// supported.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// The number of years that you want to register the domain for. Domains are
	// registered for a minimum of one year. The maximum period depends on the top-level
	// domain.
	//
	// Default: 1
	//
	// DurationInYears is a required field
	DurationInYears *int64 `min:"1" type:"integer" required:"true"`

	// Reserved for future use.
	IdnLangCode *string `type:"string"`

	// Contains details for the host and glue IP addresses.
	Nameservers []*Nameserver `type:"list"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	//
	// Default: true
	PrivacyProtectAdminContact *bool `type:"boolean"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	//
	// Default: true
	PrivacyProtectRegistrantContact *bool `type:"boolean"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	//
	// Default: true
	PrivacyProtectTechContact *bool `type:"boolean"`

	// Provides detailed contact information.
	//
	// RegistrantContact is a required field
	RegistrantContact *ContactDetail `type:"structure" required:"true"`

	// Provides detailed contact information.
	//
	// TechContact is a required field
	TechContact *ContactDetail `type:"structure" required:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *TransferDomainInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "TransferDomainInput"}
	if s.AdminContact == nil {
		invalidParams.Add(request.NewErrParamRequired("AdminContact"))
	}
	if s.DomainName == nil {
		invalidParams.Add(request.NewErrParamRequired("DomainName"))
	}
	if s.DurationInYears == nil {
		invalidParams.Add(request.NewErrParamRequired("DurationInYears"))
	}
	if s.DurationInYears != nil && *s.DurationInYears < 1 {
		invalidParams.Add(request.NewErrParamMinValue("DurationInYears", 1))
	}
	if s.RegistrantContact == nil {
		invalidParams.Add(request.NewErrParamRequired("RegistrantContact"))
	}
	if s.TechContact == nil {
		invalidParams.Add(request.NewErrParamRequired("TechContact"))
	}
	if s.AdminContact != nil {
		if err := s.AdminContact.Validate(); err != nil {
			invalidParams.AddNested("AdminContact", err.(request.ErrInvalidParams))
		}
	}
	if s.Nameservers != nil {
		for i, v := range s.Nameservers {
			if v == nil {
				continue
			}
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Nameservers", i), err.(request.ErrInvalidParams))
			}
		}
	}
	if s.RegistrantContact != nil {
		if err := s.RegistrantContact.Validate(); err != nil {
			invalidParams.AddNested("RegistrantContact", err.(request.ErrInvalidParams))
		}
	}
	if s.TechContact != nil {
		if err := s.TechContact.Validate(); err != nil {
			invalidParams.AddNested("TechContact", err.(request.ErrInvalidParams))
		}
	}

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

// SetAdminContact sets the AdminContact field's value.
func (s *TransferDomainInput) SetAdminContact(v *ContactDetail) *TransferDomainInput {
	s.AdminContact = v
	return s
}

// SetAuthCode sets the AuthCode field's value.
func (s *TransferDomainInput) SetAuthCode(v string) *TransferDomainInput {
	s.AuthCode = &v
	return s
}

// SetAutoRenew sets the AutoRenew field's value.
func (s *TransferDomainInput) SetAutoRenew(v bool) *TransferDomainInput {
	s.AutoRenew = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *TransferDomainInput) SetDomainName(v string) *TransferDomainInput {
	s.DomainName = &v
	return s
}

// SetDurationInYears sets the DurationInYears field's value.
func (s *TransferDomainInput) SetDurationInYears(v int64) *TransferDomainInput {
	s.DurationInYears = &v
	return s
}

// SetIdnLangCode sets the IdnLangCode field's value.
func (s *TransferDomainInput) SetIdnLangCode(v string) *TransferDomainInput {
	s.IdnLangCode = &v
	return s
}

// SetNameservers sets the Nameservers field's value.
func (s *TransferDomainInput) SetNameservers(v []*Nameserver) *TransferDomainInput {
	s.Nameservers = v
	return s
}

// SetPrivacyProtectAdminContact sets the PrivacyProtectAdminContact field's value.
func (s *TransferDomainInput) SetPrivacyProtectAdminContact(v bool) *TransferDomainInput {
	s.PrivacyProtectAdminContact = &v
	return s
}

// SetPrivacyProtectRegistrantContact sets the PrivacyProtectRegistrantContact field's value.
func (s *TransferDomainInput) SetPrivacyProtectRegistrantContact(v bool) *TransferDomainInput {
	s.PrivacyProtectRegistrantContact = &v
	return s
}

// SetPrivacyProtectTechContact sets the PrivacyProtectTechContact field's value.
func (s *TransferDomainInput) SetPrivacyProtectTechContact(v bool) *TransferDomainInput {
	s.PrivacyProtectTechContact = &v
	return s
}

// SetRegistrantContact sets the RegistrantContact field's value.
func (s *TransferDomainInput) SetRegistrantContact(v *ContactDetail) *TransferDomainInput {
	s.RegistrantContact = v
	return s
}

// SetTechContact sets the TechContact field's value.
func (s *TransferDomainInput) SetTechContact(v *ContactDetail) *TransferDomainInput {
	s.TechContact = v
	return s
}

// The TranserDomain response includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/TransferDomainResponse
type TransferDomainOutput struct {
	_ struct{} `type:"structure"`

	// Identifier for tracking the progress of the request. To use this ID to query
	// the operation status, use GetOperationDetail.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *TransferDomainOutput) SetOperationId(v string) *TransferDomainOutput {
	s.OperationId = &v
	return s
}

// The UpdateDomainContact request includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainContactRequest
type UpdateDomainContactInput struct {
	_ struct{} `type:"structure"`

	// Provides detailed contact information.
	AdminContact *ContactDetail `type:"structure"`

	// The name of the domain that you want to update contact information for.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// Provides detailed contact information.
	RegistrantContact *ContactDetail `type:"structure"`

	// Provides detailed contact information.
	TechContact *ContactDetail `type:"structure"`
}

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

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

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

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

// SetAdminContact sets the AdminContact field's value.
func (s *UpdateDomainContactInput) SetAdminContact(v *ContactDetail) *UpdateDomainContactInput {
	s.AdminContact = v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *UpdateDomainContactInput) SetDomainName(v string) *UpdateDomainContactInput {
	s.DomainName = &v
	return s
}

// SetRegistrantContact sets the RegistrantContact field's value.
func (s *UpdateDomainContactInput) SetRegistrantContact(v *ContactDetail) *UpdateDomainContactInput {
	s.RegistrantContact = v
	return s
}

// SetTechContact sets the TechContact field's value.
func (s *UpdateDomainContactInput) SetTechContact(v *ContactDetail) *UpdateDomainContactInput {
	s.TechContact = v
	return s
}

// The UpdateDomainContact response includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainContactResponse
type UpdateDomainContactOutput struct {
	_ struct{} `type:"structure"`

	// Identifier for tracking the progress of the request. To use this ID to query
	// the operation status, use GetOperationDetail.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *UpdateDomainContactOutput) SetOperationId(v string) *UpdateDomainContactOutput {
	s.OperationId = &v
	return s
}

// The UpdateDomainContactPrivacy request includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainContactPrivacyRequest
type UpdateDomainContactPrivacyInput struct {
	_ struct{} `type:"structure"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	AdminPrivacy *bool `type:"boolean"`

	// The name of the domain that you want to update the privacy setting for.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	RegistrantPrivacy *bool `type:"boolean"`

	// Whether you want to conceal contact information from WHOIS queries. If you
	// specify true, WHOIS ("who is") queries will return contact information for
	// our registrar partner, Gandi, instead of the contact information that you
	// enter.
	TechPrivacy *bool `type:"boolean"`
}

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

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

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

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

// SetAdminPrivacy sets the AdminPrivacy field's value.
func (s *UpdateDomainContactPrivacyInput) SetAdminPrivacy(v bool) *UpdateDomainContactPrivacyInput {
	s.AdminPrivacy = &v
	return s
}

// SetDomainName sets the DomainName field's value.
func (s *UpdateDomainContactPrivacyInput) SetDomainName(v string) *UpdateDomainContactPrivacyInput {
	s.DomainName = &v
	return s
}

// SetRegistrantPrivacy sets the RegistrantPrivacy field's value.
func (s *UpdateDomainContactPrivacyInput) SetRegistrantPrivacy(v bool) *UpdateDomainContactPrivacyInput {
	s.RegistrantPrivacy = &v
	return s
}

// SetTechPrivacy sets the TechPrivacy field's value.
func (s *UpdateDomainContactPrivacyInput) SetTechPrivacy(v bool) *UpdateDomainContactPrivacyInput {
	s.TechPrivacy = &v
	return s
}

// The UpdateDomainContactPrivacy response includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainContactPrivacyResponse
type UpdateDomainContactPrivacyOutput struct {
	_ struct{} `type:"structure"`

	// Identifier for tracking the progress of the request. To use this ID to query
	// the operation status, use GetOperationDetail.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *UpdateDomainContactPrivacyOutput) SetOperationId(v string) *UpdateDomainContactPrivacyOutput {
	s.OperationId = &v
	return s
}

// Replaces the current set of name servers for the domain with the specified
// set of name servers. If you use Amazon Route 53 as your DNS service, specify
// the four name servers in the delegation set for the hosted zone for the domain.
//
// If successful, this operation returns an operation ID that you can use to
// track the progress and completion of the action. If the request is not completed
// successfully, the domain registrant will be notified by email.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainNameserversRequest
type UpdateDomainNameserversInput struct {
	_ struct{} `type:"structure"`

	// The name of the domain that you want to change name servers for.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// The authorization key for .fi domains
	FIAuthKey *string `deprecated:"true" type:"string"`

	// A list of new name servers for the domain.
	//
	// Nameservers is a required field
	Nameservers []*Nameserver `type:"list" required:"true"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *UpdateDomainNameserversInput) SetDomainName(v string) *UpdateDomainNameserversInput {
	s.DomainName = &v
	return s
}

// SetFIAuthKey sets the FIAuthKey field's value.
func (s *UpdateDomainNameserversInput) SetFIAuthKey(v string) *UpdateDomainNameserversInput {
	s.FIAuthKey = &v
	return s
}

// SetNameservers sets the Nameservers field's value.
func (s *UpdateDomainNameserversInput) SetNameservers(v []*Nameserver) *UpdateDomainNameserversInput {
	s.Nameservers = v
	return s
}

// The UpdateDomainNameservers response includes the following element.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateDomainNameserversResponse
type UpdateDomainNameserversOutput struct {
	_ struct{} `type:"structure"`

	// Identifier for tracking the progress of the request. To use this ID to query
	// the operation status, use GetOperationDetail.
	//
	// OperationId is a required field
	OperationId *string `type:"string" required:"true"`
}

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

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

// SetOperationId sets the OperationId field's value.
func (s *UpdateDomainNameserversOutput) SetOperationId(v string) *UpdateDomainNameserversOutput {
	s.OperationId = &v
	return s
}

// The UpdateTagsForDomainRequest includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateTagsForDomainRequest
type UpdateTagsForDomainInput struct {
	_ struct{} `type:"structure"`

	// The domain for which you want to add or update tags.
	//
	// DomainName is a required field
	DomainName *string `type:"string" required:"true"`

	// A list of the tag keys and values that you want to add or update. If you
	// specify a key that already exists, the corresponding value will be replaced.
	TagsToUpdate []*Tag `type:"list"`
}

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

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

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

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

// SetDomainName sets the DomainName field's value.
func (s *UpdateTagsForDomainInput) SetDomainName(v string) *UpdateTagsForDomainInput {
	s.DomainName = &v
	return s
}

// SetTagsToUpdate sets the TagsToUpdate field's value.
func (s *UpdateTagsForDomainInput) SetTagsToUpdate(v []*Tag) *UpdateTagsForDomainInput {
	s.TagsToUpdate = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/UpdateTagsForDomainResponse
type UpdateTagsForDomainOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// The ViewBilling request includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ViewBillingRequest
type ViewBillingInput struct {
	_ struct{} `type:"structure"`

	// The end date and time for the time period for which you want a list of billing
	// records. Specify the date in Unix time format.
	End *time.Time `type:"timestamp" timestampFormat:"unix"`

	// For an initial request for a list of billing records, omit this element.
	// If the number of billing records that are associated with the current AWS
	// account during the specified period is greater than the value that you specified
	// for MaxItems, you can use Marker to return additional billing records. Get
	// the value of NextPageMarker from the previous response, and submit another
	// request that includes the value of NextPageMarker in the Marker element.
	//
	// Constraints: The marker must match the value of NextPageMarker that was returned
	// in the previous response.
	Marker *string `type:"string"`

	// The number of billing records to be returned.
	//
	// Default: 20
	MaxItems *int64 `type:"integer"`

	// The beginning date and time for the time period for which you want a list
	// of billing records. Specify the date in Unix time format.
	Start *time.Time `type:"timestamp" timestampFormat:"unix"`
}

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

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

// SetEnd sets the End field's value.
func (s *ViewBillingInput) SetEnd(v time.Time) *ViewBillingInput {
	s.End = &v
	return s
}

// SetMarker sets the Marker field's value.
func (s *ViewBillingInput) SetMarker(v string) *ViewBillingInput {
	s.Marker = &v
	return s
}

// SetMaxItems sets the MaxItems field's value.
func (s *ViewBillingInput) SetMaxItems(v int64) *ViewBillingInput {
	s.MaxItems = &v
	return s
}

// SetStart sets the Start field's value.
func (s *ViewBillingInput) SetStart(v time.Time) *ViewBillingInput {
	s.Start = &v
	return s
}

// The ViewBilling response includes the following elements.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/route53domains-2014-05-15/ViewBillingResponse
type ViewBillingOutput struct {
	_ struct{} `type:"structure"`

	// A summary of billing records.
	BillingRecords []*BillingRecord `type:"list"`

	// If there are more billing records than you specified for MaxItems in the
	// request, submit another request and include the value of NextPageMarker in
	// the value of Marker.
	NextPageMarker *string `type:"string"`
}

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

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

// SetBillingRecords sets the BillingRecords field's value.
func (s *ViewBillingOutput) SetBillingRecords(v []*BillingRecord) *ViewBillingOutput {
	s.BillingRecords = v
	return s
}

// SetNextPageMarker sets the NextPageMarker field's value.
func (s *ViewBillingOutput) SetNextPageMarker(v string) *ViewBillingOutput {
	s.NextPageMarker = &v
	return s
}

const (
	// ContactTypePerson is a ContactType enum value
	ContactTypePerson = "PERSON"

	// ContactTypeCompany is a ContactType enum value
	ContactTypeCompany = "COMPANY"

	// ContactTypeAssociation is a ContactType enum value
	ContactTypeAssociation = "ASSOCIATION"

	// ContactTypePublicBody is a ContactType enum value
	ContactTypePublicBody = "PUBLIC_BODY"

	// ContactTypeReseller is a ContactType enum value
	ContactTypeReseller = "RESELLER"
)

const (
	// CountryCodeAd is a CountryCode enum value
	CountryCodeAd = "AD"

	// CountryCodeAe is a CountryCode enum value
	CountryCodeAe = "AE"

	// CountryCodeAf is a CountryCode enum value
	CountryCodeAf = "AF"

	// CountryCodeAg is a CountryCode enum value
	CountryCodeAg = "AG"

	// CountryCodeAi is a CountryCode enum value
	CountryCodeAi = "AI"

	// CountryCodeAl is a CountryCode enum value
	CountryCodeAl = "AL"

	// CountryCodeAm is a CountryCode enum value
	CountryCodeAm = "AM"

	// CountryCodeAn is a CountryCode enum value
	CountryCodeAn = "AN"

	// CountryCodeAo is a CountryCode enum value
	CountryCodeAo = "AO"

	// CountryCodeAq is a CountryCode enum value
	CountryCodeAq = "AQ"

	// CountryCodeAr is a CountryCode enum value
	CountryCodeAr = "AR"

	// CountryCodeAs is a CountryCode enum value
	CountryCodeAs = "AS"

	// CountryCodeAt is a CountryCode enum value
	CountryCodeAt = "AT"

	// CountryCodeAu is a CountryCode enum value
	CountryCodeAu = "AU"

	// CountryCodeAw is a CountryCode enum value
	CountryCodeAw = "AW"

	// CountryCodeAz is a CountryCode enum value
	CountryCodeAz = "AZ"

	// CountryCodeBa is a CountryCode enum value
	CountryCodeBa = "BA"

	// CountryCodeBb is a CountryCode enum value
	CountryCodeBb = "BB"

	// CountryCodeBd is a CountryCode enum value
	CountryCodeBd = "BD"

	// CountryCodeBe is a CountryCode enum value
	CountryCodeBe = "BE"

	// CountryCodeBf is a CountryCode enum value
	CountryCodeBf = "BF"

	// CountryCodeBg is a CountryCode enum value
	CountryCodeBg = "BG"

	// CountryCodeBh is a CountryCode enum value
	CountryCodeBh = "BH"

	// CountryCodeBi is a CountryCode enum value
	CountryCodeBi = "BI"

	// CountryCodeBj is a CountryCode enum value
	CountryCodeBj = "BJ"

	// CountryCodeBl is a CountryCode enum value
	CountryCodeBl = "BL"

	// CountryCodeBm is a CountryCode enum value
	CountryCodeBm = "BM"

	// CountryCodeBn is a CountryCode enum value
	CountryCodeBn = "BN"

	// CountryCodeBo is a CountryCode enum value
	CountryCodeBo = "BO"

	// CountryCodeBr is a CountryCode enum value
	CountryCodeBr = "BR"

	// CountryCodeBs is a CountryCode enum value
	CountryCodeBs = "BS"

	// CountryCodeBt is a CountryCode enum value
	CountryCodeBt = "BT"

	// CountryCodeBw is a CountryCode enum value
	CountryCodeBw = "BW"

	// CountryCodeBy is a CountryCode enum value
	CountryCodeBy = "BY"

	// CountryCodeBz is a CountryCode enum value
	CountryCodeBz = "BZ"

	// CountryCodeCa is a CountryCode enum value
	CountryCodeCa = "CA"

	// CountryCodeCc is a CountryCode enum value
	CountryCodeCc = "CC"

	// CountryCodeCd is a CountryCode enum value
	CountryCodeCd = "CD"

	// CountryCodeCf is a CountryCode enum value
	CountryCodeCf = "CF"

	// CountryCodeCg is a CountryCode enum value
	CountryCodeCg = "CG"

	// CountryCodeCh is a CountryCode enum value
	CountryCodeCh = "CH"

	// CountryCodeCi is a CountryCode enum value
	CountryCodeCi = "CI"

	// CountryCodeCk is a CountryCode enum value
	CountryCodeCk = "CK"

	// CountryCodeCl is a CountryCode enum value
	CountryCodeCl = "CL"

	// CountryCodeCm is a CountryCode enum value
	CountryCodeCm = "CM"

	// CountryCodeCn is a CountryCode enum value
	CountryCodeCn = "CN"

	// CountryCodeCo is a CountryCode enum value
	CountryCodeCo = "CO"

	// CountryCodeCr is a CountryCode enum value
	CountryCodeCr = "CR"

	// CountryCodeCu is a CountryCode enum value
	CountryCodeCu = "CU"

	// CountryCodeCv is a CountryCode enum value
	CountryCodeCv = "CV"

	// CountryCodeCx is a CountryCode enum value
	CountryCodeCx = "CX"

	// CountryCodeCy is a CountryCode enum value
	CountryCodeCy = "CY"

	// CountryCodeCz is a CountryCode enum value
	CountryCodeCz = "CZ"

	// CountryCodeDe is a CountryCode enum value
	CountryCodeDe = "DE"

	// CountryCodeDj is a CountryCode enum value
	CountryCodeDj = "DJ"

	// CountryCodeDk is a CountryCode enum value
	CountryCodeDk = "DK"

	// CountryCodeDm is a CountryCode enum value
	CountryCodeDm = "DM"

	// CountryCodeDo is a CountryCode enum value
	CountryCodeDo = "DO"

	// CountryCodeDz is a CountryCode enum value
	CountryCodeDz = "DZ"

	// CountryCodeEc is a CountryCode enum value
	CountryCodeEc = "EC"

	// CountryCodeEe is a CountryCode enum value
	CountryCodeEe = "EE"

	// CountryCodeEg is a CountryCode enum value
	CountryCodeEg = "EG"

	// CountryCodeEr is a CountryCode enum value
	CountryCodeEr = "ER"

	// CountryCodeEs is a CountryCode enum value
	CountryCodeEs = "ES"

	// CountryCodeEt is a CountryCode enum value
	CountryCodeEt = "ET"

	// CountryCodeFi is a CountryCode enum value
	CountryCodeFi = "FI"

	// CountryCodeFj is a CountryCode enum value
	CountryCodeFj = "FJ"

	// CountryCodeFk is a CountryCode enum value
	CountryCodeFk = "FK"

	// CountryCodeFm is a CountryCode enum value
	CountryCodeFm = "FM"

	// CountryCodeFo is a CountryCode enum value
	CountryCodeFo = "FO"

	// CountryCodeFr is a CountryCode enum value
	CountryCodeFr = "FR"

	// CountryCodeGa is a CountryCode enum value
	CountryCodeGa = "GA"

	// CountryCodeGb is a CountryCode enum value
	CountryCodeGb = "GB"

	// CountryCodeGd is a CountryCode enum value
	CountryCodeGd = "GD"

	// CountryCodeGe is a CountryCode enum value
	CountryCodeGe = "GE"

	// CountryCodeGh is a CountryCode enum value
	CountryCodeGh = "GH"

	// CountryCodeGi is a CountryCode enum value
	CountryCodeGi = "GI"

	// CountryCodeGl is a CountryCode enum value
	CountryCodeGl = "GL"

	// CountryCodeGm is a CountryCode enum value
	CountryCodeGm = "GM"

	// CountryCodeGn is a CountryCode enum value
	CountryCodeGn = "GN"

	// CountryCodeGq is a CountryCode enum value
	CountryCodeGq = "GQ"

	// CountryCodeGr is a CountryCode enum value
	CountryCodeGr = "GR"

	// CountryCodeGt is a CountryCode enum value
	CountryCodeGt = "GT"

	// CountryCodeGu is a CountryCode enum value
	CountryCodeGu = "GU"

	// CountryCodeGw is a CountryCode enum value
	CountryCodeGw = "GW"

	// CountryCodeGy is a CountryCode enum value
	CountryCodeGy = "GY"

	// CountryCodeHk is a CountryCode enum value
	CountryCodeHk = "HK"

	// CountryCodeHn is a CountryCode enum value
	CountryCodeHn = "HN"

	// CountryCodeHr is a CountryCode enum value
	CountryCodeHr = "HR"

	// CountryCodeHt is a CountryCode enum value
	CountryCodeHt = "HT"

	// CountryCodeHu is a CountryCode enum value
	CountryCodeHu = "HU"

	// CountryCodeId is a CountryCode enum value
	CountryCodeId = "ID"

	// CountryCodeIe is a CountryCode enum value
	CountryCodeIe = "IE"

	// CountryCodeIl is a CountryCode enum value
	CountryCodeIl = "IL"

	// CountryCodeIm is a CountryCode enum value
	CountryCodeIm = "IM"

	// CountryCodeIn is a CountryCode enum value
	CountryCodeIn = "IN"

	// CountryCodeIq is a CountryCode enum value
	CountryCodeIq = "IQ"

	// CountryCodeIr is a CountryCode enum value
	CountryCodeIr = "IR"

	// CountryCodeIs is a CountryCode enum value
	CountryCodeIs = "IS"

	// CountryCodeIt is a CountryCode enum value
	CountryCodeIt = "IT"

	// CountryCodeJm is a CountryCode enum value
	CountryCodeJm = "JM"

	// CountryCodeJo is a CountryCode enum value
	CountryCodeJo = "JO"

	// CountryCodeJp is a CountryCode enum value
	CountryCodeJp = "JP"

	// CountryCodeKe is a CountryCode enum value
	CountryCodeKe = "KE"

	// CountryCodeKg is a CountryCode enum value
	CountryCodeKg = "KG"

	// CountryCodeKh is a CountryCode enum value
	CountryCodeKh = "KH"

	// CountryCodeKi is a CountryCode enum value
	CountryCodeKi = "KI"

	// CountryCodeKm is a CountryCode enum value
	CountryCodeKm = "KM"

	// CountryCodeKn is a CountryCode enum value
	CountryCodeKn = "KN"

	// CountryCodeKp is a CountryCode enum value
	CountryCodeKp = "KP"

	// CountryCodeKr is a CountryCode enum value
	CountryCodeKr = "KR"

	// CountryCodeKw is a CountryCode enum value
	CountryCodeKw = "KW"

	// CountryCodeKy is a CountryCode enum value
	CountryCodeKy = "KY"

	// CountryCodeKz is a CountryCode enum value
	CountryCodeKz = "KZ"

	// CountryCodeLa is a CountryCode enum value
	CountryCodeLa = "LA"

	// CountryCodeLb is a CountryCode enum value
	CountryCodeLb = "LB"

	// CountryCodeLc is a CountryCode enum value
	CountryCodeLc = "LC"

	// CountryCodeLi is a CountryCode enum value
	CountryCodeLi = "LI"

	// CountryCodeLk is a CountryCode enum value
	CountryCodeLk = "LK"

	// CountryCodeLr is a CountryCode enum value
	CountryCodeLr = "LR"

	// CountryCodeLs is a CountryCode enum value
	CountryCodeLs = "LS"

	// CountryCodeLt is a CountryCode enum value
	CountryCodeLt = "LT"

	// CountryCodeLu is a CountryCode enum value
	CountryCodeLu = "LU"

	// CountryCodeLv is a CountryCode enum value
	CountryCodeLv = "LV"

	// CountryCodeLy is a CountryCode enum value
	CountryCodeLy = "LY"

	// CountryCodeMa is a CountryCode enum value
	CountryCodeMa = "MA"

	// CountryCodeMc is a CountryCode enum value
	CountryCodeMc = "MC"

	// CountryCodeMd is a CountryCode enum value
	CountryCodeMd = "MD"

	// CountryCodeMe is a CountryCode enum value
	CountryCodeMe = "ME"

	// CountryCodeMf is a CountryCode enum value
	CountryCodeMf = "MF"

	// CountryCodeMg is a CountryCode enum value
	CountryCodeMg = "MG"

	// CountryCodeMh is a CountryCode enum value
	CountryCodeMh = "MH"

	// CountryCodeMk is a CountryCode enum value
	CountryCodeMk = "MK"

	// CountryCodeMl is a CountryCode enum value
	CountryCodeMl = "ML"

	// CountryCodeMm is a CountryCode enum value
	CountryCodeMm = "MM"

	// CountryCodeMn is a CountryCode enum value
	CountryCodeMn = "MN"

	// CountryCodeMo is a CountryCode enum value
	CountryCodeMo = "MO"

	// CountryCodeMp is a CountryCode enum value
	CountryCodeMp = "MP"

	// CountryCodeMr is a CountryCode enum value
	CountryCodeMr = "MR"

	// CountryCodeMs is a CountryCode enum value
	CountryCodeMs = "MS"

	// CountryCodeMt is a CountryCode enum value
	CountryCodeMt = "MT"

	// CountryCodeMu is a CountryCode enum value
	CountryCodeMu = "MU"

	// CountryCodeMv is a CountryCode enum value
	CountryCodeMv = "MV"

	// CountryCodeMw is a CountryCode enum value
	CountryCodeMw = "MW"

	// CountryCodeMx is a CountryCode enum value
	CountryCodeMx = "MX"

	// CountryCodeMy is a CountryCode enum value
	CountryCodeMy = "MY"

	// CountryCodeMz is a CountryCode enum value
	CountryCodeMz = "MZ"

	// CountryCodeNa is a CountryCode enum value
	CountryCodeNa = "NA"

	// CountryCodeNc is a CountryCode enum value
	CountryCodeNc = "NC"

	// CountryCodeNe is a CountryCode enum value
	CountryCodeNe = "NE"

	// CountryCodeNg is a CountryCode enum value
	CountryCodeNg = "NG"

	// CountryCodeNi is a CountryCode enum value
	CountryCodeNi = "NI"

	// CountryCodeNl is a CountryCode enum value
	CountryCodeNl = "NL"

	// CountryCodeNo is a CountryCode enum value
	CountryCodeNo = "NO"

	// CountryCodeNp is a CountryCode enum value
	CountryCodeNp = "NP"

	// CountryCodeNr is a CountryCode enum value
	CountryCodeNr = "NR"

	// CountryCodeNu is a CountryCode enum value
	CountryCodeNu = "NU"

	// CountryCodeNz is a CountryCode enum value
	CountryCodeNz = "NZ"

	// CountryCodeOm is a CountryCode enum value
	CountryCodeOm = "OM"

	// CountryCodePa is a CountryCode enum value
	CountryCodePa = "PA"

	// CountryCodePe is a CountryCode enum value
	CountryCodePe = "PE"

	// CountryCodePf is a CountryCode enum value
	CountryCodePf = "PF"

	// CountryCodePg is a CountryCode enum value
	CountryCodePg = "PG"

	// CountryCodePh is a CountryCode enum value
	CountryCodePh = "PH"

	// CountryCodePk is a CountryCode enum value
	CountryCodePk = "PK"

	// CountryCodePl is a CountryCode enum value
	CountryCodePl = "PL"

	// CountryCodePm is a CountryCode enum value
	CountryCodePm = "PM"

	// CountryCodePn is a CountryCode enum value
	CountryCodePn = "PN"

	// CountryCodePr is a CountryCode enum value
	CountryCodePr = "PR"

	// CountryCodePt is a CountryCode enum value
	CountryCodePt = "PT"

	// CountryCodePw is a CountryCode enum value
	CountryCodePw = "PW"

	// CountryCodePy is a CountryCode enum value
	CountryCodePy = "PY"

	// CountryCodeQa is a CountryCode enum value
	CountryCodeQa = "QA"

	// CountryCodeRo is a CountryCode enum value
	CountryCodeRo = "RO"

	// CountryCodeRs is a CountryCode enum value
	CountryCodeRs = "RS"

	// CountryCodeRu is a CountryCode enum value
	CountryCodeRu = "RU"

	// CountryCodeRw is a CountryCode enum value
	CountryCodeRw = "RW"

	// CountryCodeSa is a CountryCode enum value
	CountryCodeSa = "SA"

	// CountryCodeSb is a CountryCode enum value
	CountryCodeSb = "SB"

	// CountryCodeSc is a CountryCode enum value
	CountryCodeSc = "SC"

	// CountryCodeSd is a CountryCode enum value
	CountryCodeSd = "SD"

	// CountryCodeSe is a CountryCode enum value
	CountryCodeSe = "SE"

	// CountryCodeSg is a CountryCode enum value
	CountryCodeSg = "SG"

	// CountryCodeSh is a CountryCode enum value
	CountryCodeSh = "SH"

	// CountryCodeSi is a CountryCode enum value
	CountryCodeSi = "SI"

	// CountryCodeSk is a CountryCode enum value
	CountryCodeSk = "SK"

	// CountryCodeSl is a CountryCode enum value
	CountryCodeSl = "SL"

	// CountryCodeSm is a CountryCode enum value
	CountryCodeSm = "SM"

	// CountryCodeSn is a CountryCode enum value
	CountryCodeSn = "SN"

	// CountryCodeSo is a CountryCode enum value
	CountryCodeSo = "SO"

	// CountryCodeSr is a CountryCode enum value
	CountryCodeSr = "SR"

	// CountryCodeSt is a CountryCode enum value
	CountryCodeSt = "ST"

	// CountryCodeSv is a CountryCode enum value
	CountryCodeSv = "SV"

	// CountryCodeSy is a CountryCode enum value
	CountryCodeSy = "SY"

	// CountryCodeSz is a CountryCode enum value
	CountryCodeSz = "SZ"

	// CountryCodeTc is a CountryCode enum value
	CountryCodeTc = "TC"

	// CountryCodeTd is a CountryCode enum value
	CountryCodeTd = "TD"

	// CountryCodeTg is a CountryCode enum value
	CountryCodeTg = "TG"

	// CountryCodeTh is a CountryCode enum value
	CountryCodeTh = "TH"

	// CountryCodeTj is a CountryCode enum value
	CountryCodeTj = "TJ"

	// CountryCodeTk is a CountryCode enum value
	CountryCodeTk = "TK"

	// CountryCodeTl is a CountryCode enum value
	CountryCodeTl = "TL"

	// CountryCodeTm is a CountryCode enum value
	CountryCodeTm = "TM"

	// CountryCodeTn is a CountryCode enum value
	CountryCodeTn = "TN"

	// CountryCodeTo is a CountryCode enum value
	CountryCodeTo = "TO"

	// CountryCodeTr is a CountryCode enum value
	CountryCodeTr = "TR"

	// CountryCodeTt is a CountryCode enum value
	CountryCodeTt = "TT"

	// CountryCodeTv is a CountryCode enum value
	CountryCodeTv = "TV"

	// CountryCodeTw is a CountryCode enum value
	CountryCodeTw = "TW"

	// CountryCodeTz is a CountryCode enum value
	CountryCodeTz = "TZ"

	// CountryCodeUa is a CountryCode enum value
	CountryCodeUa = "UA"

	// CountryCodeUg is a CountryCode enum value
	CountryCodeUg = "UG"

	// CountryCodeUs is a CountryCode enum value
	CountryCodeUs = "US"

	// CountryCodeUy is a CountryCode enum value
	CountryCodeUy = "UY"

	// CountryCodeUz is a CountryCode enum value
	CountryCodeUz = "UZ"

	// CountryCodeVa is a CountryCode enum value
	CountryCodeVa = "VA"

	// CountryCodeVc is a CountryCode enum value
	CountryCodeVc = "VC"

	// CountryCodeVe is a CountryCode enum value
	CountryCodeVe = "VE"

	// CountryCodeVg is a CountryCode enum value
	CountryCodeVg = "VG"

	// CountryCodeVi is a CountryCode enum value
	CountryCodeVi = "VI"

	// CountryCodeVn is a CountryCode enum value
	CountryCodeVn = "VN"

	// CountryCodeVu is a CountryCode enum value
	CountryCodeVu = "VU"

	// CountryCodeWf is a CountryCode enum value
	CountryCodeWf = "WF"

	// CountryCodeWs is a CountryCode enum value
	CountryCodeWs = "WS"

	// CountryCodeYe is a CountryCode enum value
	CountryCodeYe = "YE"

	// CountryCodeYt is a CountryCode enum value
	CountryCodeYt = "YT"

	// CountryCodeZa is a CountryCode enum value
	CountryCodeZa = "ZA"

	// CountryCodeZm is a CountryCode enum value
	CountryCodeZm = "ZM"

	// CountryCodeZw is a CountryCode enum value
	CountryCodeZw = "ZW"
)

const (
	// DomainAvailabilityAvailable is a DomainAvailability enum value
	DomainAvailabilityAvailable = "AVAILABLE"

	// DomainAvailabilityAvailableReserved is a DomainAvailability enum value
	DomainAvailabilityAvailableReserved = "AVAILABLE_RESERVED"

	// DomainAvailabilityAvailablePreorder is a DomainAvailability enum value
	DomainAvailabilityAvailablePreorder = "AVAILABLE_PREORDER"

	// DomainAvailabilityUnavailable is a DomainAvailability enum value
	DomainAvailabilityUnavailable = "UNAVAILABLE"

	// DomainAvailabilityUnavailablePremium is a DomainAvailability enum value
	DomainAvailabilityUnavailablePremium = "UNAVAILABLE_PREMIUM"

	// DomainAvailabilityUnavailableRestricted is a DomainAvailability enum value
	DomainAvailabilityUnavailableRestricted = "UNAVAILABLE_RESTRICTED"

	// DomainAvailabilityReserved is a DomainAvailability enum value
	DomainAvailabilityReserved = "RESERVED"

	// DomainAvailabilityDontKnow is a DomainAvailability enum value
	DomainAvailabilityDontKnow = "DONT_KNOW"
)

const (
	// ExtraParamNameDunsNumber is a ExtraParamName enum value
	ExtraParamNameDunsNumber = "DUNS_NUMBER"

	// ExtraParamNameBrandNumber is a ExtraParamName enum value
	ExtraParamNameBrandNumber = "BRAND_NUMBER"

	// ExtraParamNameBirthDepartment is a ExtraParamName enum value
	ExtraParamNameBirthDepartment = "BIRTH_DEPARTMENT"

	// ExtraParamNameBirthDateInYyyyMmDd is a ExtraParamName enum value
	ExtraParamNameBirthDateInYyyyMmDd = "BIRTH_DATE_IN_YYYY_MM_DD"

	// ExtraParamNameBirthCountry is a ExtraParamName enum value
	ExtraParamNameBirthCountry = "BIRTH_COUNTRY"

	// ExtraParamNameBirthCity is a ExtraParamName enum value
	ExtraParamNameBirthCity = "BIRTH_CITY"

	// ExtraParamNameDocumentNumber is a ExtraParamName enum value
	ExtraParamNameDocumentNumber = "DOCUMENT_NUMBER"

	// ExtraParamNameAuIdNumber is a ExtraParamName enum value
	ExtraParamNameAuIdNumber = "AU_ID_NUMBER"

	// ExtraParamNameAuIdType is a ExtraParamName enum value
	ExtraParamNameAuIdType = "AU_ID_TYPE"

	// ExtraParamNameCaLegalType is a ExtraParamName enum value
	ExtraParamNameCaLegalType = "CA_LEGAL_TYPE"

	// ExtraParamNameCaBusinessEntityType is a ExtraParamName enum value
	ExtraParamNameCaBusinessEntityType = "CA_BUSINESS_ENTITY_TYPE"

	// ExtraParamNameEsIdentification is a ExtraParamName enum value
	ExtraParamNameEsIdentification = "ES_IDENTIFICATION"

	// ExtraParamNameEsIdentificationType is a ExtraParamName enum value
	ExtraParamNameEsIdentificationType = "ES_IDENTIFICATION_TYPE"

	// ExtraParamNameEsLegalForm is a ExtraParamName enum value
	ExtraParamNameEsLegalForm = "ES_LEGAL_FORM"

	// ExtraParamNameFiBusinessNumber is a ExtraParamName enum value
	ExtraParamNameFiBusinessNumber = "FI_BUSINESS_NUMBER"

	// ExtraParamNameFiIdNumber is a ExtraParamName enum value
	ExtraParamNameFiIdNumber = "FI_ID_NUMBER"

	// ExtraParamNameFiNationality is a ExtraParamName enum value
	ExtraParamNameFiNationality = "FI_NATIONALITY"

	// ExtraParamNameFiOrganizationType is a ExtraParamName enum value
	ExtraParamNameFiOrganizationType = "FI_ORGANIZATION_TYPE"

	// ExtraParamNameItPin is a ExtraParamName enum value
	ExtraParamNameItPin = "IT_PIN"

	// ExtraParamNameItRegistrantEntityType is a ExtraParamName enum value
	ExtraParamNameItRegistrantEntityType = "IT_REGISTRANT_ENTITY_TYPE"

	// ExtraParamNameRuPassportData is a ExtraParamName enum value
	ExtraParamNameRuPassportData = "RU_PASSPORT_DATA"

	// ExtraParamNameSeIdNumber is a ExtraParamName enum value
	ExtraParamNameSeIdNumber = "SE_ID_NUMBER"

	// ExtraParamNameSgIdNumber is a ExtraParamName enum value
	ExtraParamNameSgIdNumber = "SG_ID_NUMBER"

	// ExtraParamNameVatNumber is a ExtraParamName enum value
	ExtraParamNameVatNumber = "VAT_NUMBER"

	// ExtraParamNameUkContactType is a ExtraParamName enum value
	ExtraParamNameUkContactType = "UK_CONTACT_TYPE"

	// ExtraParamNameUkCompanyNumber is a ExtraParamName enum value
	ExtraParamNameUkCompanyNumber = "UK_COMPANY_NUMBER"
)

const (
	// OperationStatusSubmitted is a OperationStatus enum value
	OperationStatusSubmitted = "SUBMITTED"

	// OperationStatusInProgress is a OperationStatus enum value
	OperationStatusInProgress = "IN_PROGRESS"

	// OperationStatusError is a OperationStatus enum value
	OperationStatusError = "ERROR"

	// OperationStatusSuccessful is a OperationStatus enum value
	OperationStatusSuccessful = "SUCCESSFUL"

	// OperationStatusFailed is a OperationStatus enum value
	OperationStatusFailed = "FAILED"
)

const (
	// OperationTypeRegisterDomain is a OperationType enum value
	OperationTypeRegisterDomain = "REGISTER_DOMAIN"

	// OperationTypeDeleteDomain is a OperationType enum value
	OperationTypeDeleteDomain = "DELETE_DOMAIN"

	// OperationTypeTransferInDomain is a OperationType enum value
	OperationTypeTransferInDomain = "TRANSFER_IN_DOMAIN"

	// OperationTypeUpdateDomainContact is a OperationType enum value
	OperationTypeUpdateDomainContact = "UPDATE_DOMAIN_CONTACT"

	// OperationTypeUpdateNameserver is a OperationType enum value
	OperationTypeUpdateNameserver = "UPDATE_NAMESERVER"

	// OperationTypeChangePrivacyProtection is a OperationType enum value
	OperationTypeChangePrivacyProtection = "CHANGE_PRIVACY_PROTECTION"

	// OperationTypeDomainLock is a OperationType enum value
	OperationTypeDomainLock = "DOMAIN_LOCK"

	// OperationTypeEnableAutorenew is a OperationType enum value
	OperationTypeEnableAutorenew = "ENABLE_AUTORENEW"

	// OperationTypeDisableAutorenew is a OperationType enum value
	OperationTypeDisableAutorenew = "DISABLE_AUTORENEW"

	// OperationTypeAddDnssec is a OperationType enum value
	OperationTypeAddDnssec = "ADD_DNSSEC"

	// OperationTypeRemoveDnssec is a OperationType enum value
	OperationTypeRemoveDnssec = "REMOVE_DNSSEC"

	// OperationTypeExpireDomain is a OperationType enum value
	OperationTypeExpireDomain = "EXPIRE_DOMAIN"

	// OperationTypeTransferOutDomain is a OperationType enum value
	OperationTypeTransferOutDomain = "TRANSFER_OUT_DOMAIN"

	// OperationTypeChangeDomainOwner is a OperationType enum value
	OperationTypeChangeDomainOwner = "CHANGE_DOMAIN_OWNER"

	// OperationTypeRenewDomain is a OperationType enum value
	OperationTypeRenewDomain = "RENEW_DOMAIN"

	// OperationTypePushDomain is a OperationType enum value
	OperationTypePushDomain = "PUSH_DOMAIN"
)

const (
	// ReachabilityStatusPending is a ReachabilityStatus enum value
	ReachabilityStatusPending = "PENDING"

	// ReachabilityStatusDone is a ReachabilityStatus enum value
	ReachabilityStatusDone = "DONE"

	// ReachabilityStatusExpired is a ReachabilityStatus enum value
	ReachabilityStatusExpired = "EXPIRED"
)

// Whether the domain name can be transferred to Amazon Route 53.
//
// You can transfer only domains that have a value of TRANSFERABLE for Transferable.
//
// Valid values:
//
// TRANSFERABLEThe domain name can be transferred to Amazon Route 53.
//
// UNTRANSFERRABLEThe domain name can't be transferred to Amazon Route 53.
//
// DONT_KNOWReserved for future use.
const (
	// TransferableTransferable is a Transferable enum value
	TransferableTransferable = "TRANSFERABLE"

	// TransferableUntransferable is a Transferable enum value
	TransferableUntransferable = "UNTRANSFERABLE"

	// TransferableDontKnow is a Transferable enum value
	TransferableDontKnow = "DONT_KNOW"
)