rclone/vendor/github.com/aws/aws-sdk-go/service/directoryservice/api.go

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

package directoryservice

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 opAddIpRoutes = "AddIpRoutes"

// AddIpRoutesRequest generates a "aws/request.Request" representing the
// client's request for the AddIpRoutes operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 AddIpRoutes for more information on using the AddIpRoutes
// 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 AddIpRoutesRequest method.
//    req, resp := client.AddIpRoutesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/AddIpRoutes
func (c *DirectoryService) AddIpRoutesRequest(input *AddIpRoutesInput) (req *request.Request, output *AddIpRoutesOutput) {
	op := &request.Operation{
		Name:       opAddIpRoutes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AddIpRoutesInput{}
	}

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

// AddIpRoutes API operation for AWS Directory Service.
//
// If the DNS server for your on-premises domain uses a publicly addressable
// IP address, you must add a CIDR address block to correctly route traffic
// to and from your Microsoft AD on Amazon Web Services. AddIpRoutes adds this
// address block. You can also use AddIpRoutes to facilitate routing traffic
// that uses public IP ranges from your Microsoft AD on AWS to a peer VPC.
//
// Before you call AddIpRoutes, ensure that all of the required permissions
// have been explicitly granted through a policy. For details about what permissions
// are required to run the AddIpRoutes operation, see AWS Directory Service
// API Permissions: Actions, Resources, and Conditions Reference (http://docs.aws.amazon.com/directoryservice/latest/admin-guide/UsingWithDS_IAM_ResourcePermissions.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for AWS Directory Service's
// API operation AddIpRoutes for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExistsException"
//   The specified entity already exists.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeIpRouteLimitExceededException "IpRouteLimitExceededException"
//   The maximum allowed number of IP addresses was exceeded. The default limit
//   is 100 IP address blocks.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/AddIpRoutes
func (c *DirectoryService) AddIpRoutes(input *AddIpRoutesInput) (*AddIpRoutesOutput, error) {
	req, out := c.AddIpRoutesRequest(input)
	return out, req.Send()
}

// AddIpRoutesWithContext is the same as AddIpRoutes with the addition of
// the ability to pass a context and additional request options.
//
// See AddIpRoutes 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 *DirectoryService) AddIpRoutesWithContext(ctx aws.Context, input *AddIpRoutesInput, opts ...request.Option) (*AddIpRoutesOutput, error) {
	req, out := c.AddIpRoutesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opAddTagsToResource = "AddTagsToResource"

// AddTagsToResourceRequest generates a "aws/request.Request" representing the
// client's request for the AddTagsToResource operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 AddTagsToResource for more information on using the AddTagsToResource
// 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 AddTagsToResourceRequest method.
//    req, resp := client.AddTagsToResourceRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/AddTagsToResource
func (c *DirectoryService) AddTagsToResourceRequest(input *AddTagsToResourceInput) (req *request.Request, output *AddTagsToResourceOutput) {
	op := &request.Operation{
		Name:       opAddTagsToResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AddTagsToResourceInput{}
	}

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

// AddTagsToResource API operation for AWS Directory Service.
//
// Adds or overwrites one or more tags for the specified directory. Each directory
// can have a maximum of 50 tags. Each tag consists of a key and optional value.
// Tag keys must be unique to each resource.
//
// 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 AWS Directory Service's
// API operation AddTagsToResource for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeTagLimitExceededException "TagLimitExceededException"
//   The maximum allowed number of tags was exceeded.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/AddTagsToResource
func (c *DirectoryService) AddTagsToResource(input *AddTagsToResourceInput) (*AddTagsToResourceOutput, error) {
	req, out := c.AddTagsToResourceRequest(input)
	return out, req.Send()
}

// AddTagsToResourceWithContext is the same as AddTagsToResource with the addition of
// the ability to pass a context and additional request options.
//
// See AddTagsToResource 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 *DirectoryService) AddTagsToResourceWithContext(ctx aws.Context, input *AddTagsToResourceInput, opts ...request.Option) (*AddTagsToResourceOutput, error) {
	req, out := c.AddTagsToResourceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCancelSchemaExtension = "CancelSchemaExtension"

// CancelSchemaExtensionRequest generates a "aws/request.Request" representing the
// client's request for the CancelSchemaExtension operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 CancelSchemaExtension for more information on using the CancelSchemaExtension
// 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 CancelSchemaExtensionRequest method.
//    req, resp := client.CancelSchemaExtensionRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CancelSchemaExtension
func (c *DirectoryService) CancelSchemaExtensionRequest(input *CancelSchemaExtensionInput) (req *request.Request, output *CancelSchemaExtensionOutput) {
	op := &request.Operation{
		Name:       opCancelSchemaExtension,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CancelSchemaExtensionInput{}
	}

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

// CancelSchemaExtension API operation for AWS Directory Service.
//
// Cancels an in-progress schema extension to a Microsoft AD directory. Once
// a schema extension has started replicating to all domain controllers, the
// task can no longer be canceled. A schema extension can be canceled during
// any of the following states; Initializing, CreatingSnapshot, and UpdatingSchema.
//
// 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 AWS Directory Service's
// API operation CancelSchemaExtension for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CancelSchemaExtension
func (c *DirectoryService) CancelSchemaExtension(input *CancelSchemaExtensionInput) (*CancelSchemaExtensionOutput, error) {
	req, out := c.CancelSchemaExtensionRequest(input)
	return out, req.Send()
}

// CancelSchemaExtensionWithContext is the same as CancelSchemaExtension with the addition of
// the ability to pass a context and additional request options.
//
// See CancelSchemaExtension 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 *DirectoryService) CancelSchemaExtensionWithContext(ctx aws.Context, input *CancelSchemaExtensionInput, opts ...request.Option) (*CancelSchemaExtensionOutput, error) {
	req, out := c.CancelSchemaExtensionRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opConnectDirectory = "ConnectDirectory"

// ConnectDirectoryRequest generates a "aws/request.Request" representing the
// client's request for the ConnectDirectory operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 ConnectDirectory for more information on using the ConnectDirectory
// 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 ConnectDirectoryRequest method.
//    req, resp := client.ConnectDirectoryRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ConnectDirectory
func (c *DirectoryService) ConnectDirectoryRequest(input *ConnectDirectoryInput) (req *request.Request, output *ConnectDirectoryOutput) {
	op := &request.Operation{
		Name:       opConnectDirectory,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ConnectDirectoryInput{}
	}

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

// ConnectDirectory API operation for AWS Directory Service.
//
// Creates an AD Connector to connect to an on-premises directory.
//
// Before you call ConnectDirectory, ensure that all of the required permissions
// have been explicitly granted through a policy. For details about what permissions
// are required to run the ConnectDirectory operation, see AWS Directory Service
// API Permissions: Actions, Resources, and Conditions Reference (http://docs.aws.amazon.com/directoryservice/latest/admin-guide/UsingWithDS_IAM_ResourcePermissions.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for AWS Directory Service's
// API operation ConnectDirectory for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeDirectoryLimitExceededException "DirectoryLimitExceededException"
//   The maximum number of directories in the region has been reached. You can
//   use the GetDirectoryLimits operation to determine your directory limits in
//   the region.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ConnectDirectory
func (c *DirectoryService) ConnectDirectory(input *ConnectDirectoryInput) (*ConnectDirectoryOutput, error) {
	req, out := c.ConnectDirectoryRequest(input)
	return out, req.Send()
}

// ConnectDirectoryWithContext is the same as ConnectDirectory with the addition of
// the ability to pass a context and additional request options.
//
// See ConnectDirectory 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 *DirectoryService) ConnectDirectoryWithContext(ctx aws.Context, input *ConnectDirectoryInput, opts ...request.Option) (*ConnectDirectoryOutput, error) {
	req, out := c.ConnectDirectoryRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateAlias = "CreateAlias"

// CreateAliasRequest generates a "aws/request.Request" representing the
// client's request for the CreateAlias operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 CreateAlias for more information on using the CreateAlias
// 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 CreateAliasRequest method.
//    req, resp := client.CreateAliasRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateAlias
func (c *DirectoryService) CreateAliasRequest(input *CreateAliasInput) (req *request.Request, output *CreateAliasOutput) {
	op := &request.Operation{
		Name:       opCreateAlias,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateAliasInput{}
	}

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

// CreateAlias API operation for AWS Directory Service.
//
// Creates an alias for a directory and assigns the alias to the directory.
// The alias is used to construct the access URL for the directory, such as
// http://<alias>.awsapps.com.
//
// After an alias has been created, it cannot be deleted or reused, so this
// operation should only be used when absolutely necessary.
//
// 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 AWS Directory Service's
// API operation CreateAlias for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExistsException"
//   The specified entity already exists.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateAlias
func (c *DirectoryService) CreateAlias(input *CreateAliasInput) (*CreateAliasOutput, error) {
	req, out := c.CreateAliasRequest(input)
	return out, req.Send()
}

// CreateAliasWithContext is the same as CreateAlias with the addition of
// the ability to pass a context and additional request options.
//
// See CreateAlias 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 *DirectoryService) CreateAliasWithContext(ctx aws.Context, input *CreateAliasInput, opts ...request.Option) (*CreateAliasOutput, error) {
	req, out := c.CreateAliasRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateComputer = "CreateComputer"

// CreateComputerRequest generates a "aws/request.Request" representing the
// client's request for the CreateComputer operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 CreateComputer for more information on using the CreateComputer
// 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 CreateComputerRequest method.
//    req, resp := client.CreateComputerRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateComputer
func (c *DirectoryService) CreateComputerRequest(input *CreateComputerInput) (req *request.Request, output *CreateComputerOutput) {
	op := &request.Operation{
		Name:       opCreateComputer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateComputerInput{}
	}

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

// CreateComputer API operation for AWS Directory Service.
//
// Creates a computer account in the specified directory, and joins the computer
// to the directory.
//
// 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 AWS Directory Service's
// API operation CreateComputer for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeAuthenticationFailedException "AuthenticationFailedException"
//   An authentication error occurred.
//
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExistsException"
//   The specified entity already exists.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateComputer
func (c *DirectoryService) CreateComputer(input *CreateComputerInput) (*CreateComputerOutput, error) {
	req, out := c.CreateComputerRequest(input)
	return out, req.Send()
}

// CreateComputerWithContext is the same as CreateComputer with the addition of
// the ability to pass a context and additional request options.
//
// See CreateComputer 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 *DirectoryService) CreateComputerWithContext(ctx aws.Context, input *CreateComputerInput, opts ...request.Option) (*CreateComputerOutput, error) {
	req, out := c.CreateComputerRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateConditionalForwarder = "CreateConditionalForwarder"

// CreateConditionalForwarderRequest generates a "aws/request.Request" representing the
// client's request for the CreateConditionalForwarder operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 CreateConditionalForwarder for more information on using the CreateConditionalForwarder
// 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 CreateConditionalForwarderRequest method.
//    req, resp := client.CreateConditionalForwarderRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateConditionalForwarder
func (c *DirectoryService) CreateConditionalForwarderRequest(input *CreateConditionalForwarderInput) (req *request.Request, output *CreateConditionalForwarderOutput) {
	op := &request.Operation{
		Name:       opCreateConditionalForwarder,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateConditionalForwarderInput{}
	}

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

// CreateConditionalForwarder API operation for AWS Directory Service.
//
// Creates a conditional forwarder associated with your AWS directory. Conditional
// forwarders are required in order to set up a trust relationship with another
// domain. The conditional forwarder points to the trusted 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 AWS Directory Service's
// API operation CreateConditionalForwarder for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExistsException"
//   The specified entity already exists.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateConditionalForwarder
func (c *DirectoryService) CreateConditionalForwarder(input *CreateConditionalForwarderInput) (*CreateConditionalForwarderOutput, error) {
	req, out := c.CreateConditionalForwarderRequest(input)
	return out, req.Send()
}

// CreateConditionalForwarderWithContext is the same as CreateConditionalForwarder with the addition of
// the ability to pass a context and additional request options.
//
// See CreateConditionalForwarder 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 *DirectoryService) CreateConditionalForwarderWithContext(ctx aws.Context, input *CreateConditionalForwarderInput, opts ...request.Option) (*CreateConditionalForwarderOutput, error) {
	req, out := c.CreateConditionalForwarderRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateDirectory = "CreateDirectory"

// CreateDirectoryRequest generates a "aws/request.Request" representing the
// client's request for the CreateDirectory operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 CreateDirectory for more information on using the CreateDirectory
// 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 CreateDirectoryRequest method.
//    req, resp := client.CreateDirectoryRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateDirectory
func (c *DirectoryService) CreateDirectoryRequest(input *CreateDirectoryInput) (req *request.Request, output *CreateDirectoryOutput) {
	op := &request.Operation{
		Name:       opCreateDirectory,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateDirectoryInput{}
	}

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

// CreateDirectory API operation for AWS Directory Service.
//
// Creates a Simple AD directory.
//
// Before you call CreateDirectory, ensure that all of the required permissions
// have been explicitly granted through a policy. For details about what permissions
// are required to run the CreateDirectory operation, see AWS Directory Service
// API Permissions: Actions, Resources, and Conditions Reference (http://docs.aws.amazon.com/directoryservice/latest/admin-guide/UsingWithDS_IAM_ResourcePermissions.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for AWS Directory Service's
// API operation CreateDirectory for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeDirectoryLimitExceededException "DirectoryLimitExceededException"
//   The maximum number of directories in the region has been reached. You can
//   use the GetDirectoryLimits operation to determine your directory limits in
//   the region.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateDirectory
func (c *DirectoryService) CreateDirectory(input *CreateDirectoryInput) (*CreateDirectoryOutput, error) {
	req, out := c.CreateDirectoryRequest(input)
	return out, req.Send()
}

// CreateDirectoryWithContext is the same as CreateDirectory with the addition of
// the ability to pass a context and additional request options.
//
// See CreateDirectory 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 *DirectoryService) CreateDirectoryWithContext(ctx aws.Context, input *CreateDirectoryInput, opts ...request.Option) (*CreateDirectoryOutput, error) {
	req, out := c.CreateDirectoryRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateMicrosoftAD = "CreateMicrosoftAD"

// CreateMicrosoftADRequest generates a "aws/request.Request" representing the
// client's request for the CreateMicrosoftAD operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 CreateMicrosoftAD for more information on using the CreateMicrosoftAD
// 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 CreateMicrosoftADRequest method.
//    req, resp := client.CreateMicrosoftADRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateMicrosoftAD
func (c *DirectoryService) CreateMicrosoftADRequest(input *CreateMicrosoftADInput) (req *request.Request, output *CreateMicrosoftADOutput) {
	op := &request.Operation{
		Name:       opCreateMicrosoftAD,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateMicrosoftADInput{}
	}

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

// CreateMicrosoftAD API operation for AWS Directory Service.
//
// Creates a Microsoft AD in the AWS cloud.
//
// Before you call CreateMicrosoftAD, ensure that all of the required permissions
// have been explicitly granted through a policy. For details about what permissions
// are required to run the CreateMicrosoftAD operation, see AWS Directory Service
// API Permissions: Actions, Resources, and Conditions Reference (http://docs.aws.amazon.com/directoryservice/latest/admin-guide/UsingWithDS_IAM_ResourcePermissions.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for AWS Directory Service's
// API operation CreateMicrosoftAD for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeDirectoryLimitExceededException "DirectoryLimitExceededException"
//   The maximum number of directories in the region has been reached. You can
//   use the GetDirectoryLimits operation to determine your directory limits in
//   the region.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateMicrosoftAD
func (c *DirectoryService) CreateMicrosoftAD(input *CreateMicrosoftADInput) (*CreateMicrosoftADOutput, error) {
	req, out := c.CreateMicrosoftADRequest(input)
	return out, req.Send()
}

// CreateMicrosoftADWithContext is the same as CreateMicrosoftAD with the addition of
// the ability to pass a context and additional request options.
//
// See CreateMicrosoftAD 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 *DirectoryService) CreateMicrosoftADWithContext(ctx aws.Context, input *CreateMicrosoftADInput, opts ...request.Option) (*CreateMicrosoftADOutput, error) {
	req, out := c.CreateMicrosoftADRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateSnapshot = "CreateSnapshot"

// CreateSnapshotRequest generates a "aws/request.Request" representing the
// client's request for the CreateSnapshot operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 CreateSnapshot for more information on using the CreateSnapshot
// 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 CreateSnapshotRequest method.
//    req, resp := client.CreateSnapshotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateSnapshot
func (c *DirectoryService) CreateSnapshotRequest(input *CreateSnapshotInput) (req *request.Request, output *CreateSnapshotOutput) {
	op := &request.Operation{
		Name:       opCreateSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateSnapshotInput{}
	}

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

// CreateSnapshot API operation for AWS Directory Service.
//
// Creates a snapshot of a Simple AD or Microsoft AD directory in the AWS cloud.
//
// You cannot take snapshots of AD Connector directories.
//
// 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 AWS Directory Service's
// API operation CreateSnapshot for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeSnapshotLimitExceededException "SnapshotLimitExceededException"
//   The maximum number of manual snapshots for the directory has been reached.
//   You can use the GetSnapshotLimits operation to determine the snapshot limits
//   for a directory.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateSnapshot
func (c *DirectoryService) CreateSnapshot(input *CreateSnapshotInput) (*CreateSnapshotOutput, error) {
	req, out := c.CreateSnapshotRequest(input)
	return out, req.Send()
}

// CreateSnapshotWithContext is the same as CreateSnapshot with the addition of
// the ability to pass a context and additional request options.
//
// See CreateSnapshot 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 *DirectoryService) CreateSnapshotWithContext(ctx aws.Context, input *CreateSnapshotInput, opts ...request.Option) (*CreateSnapshotOutput, error) {
	req, out := c.CreateSnapshotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opCreateTrust = "CreateTrust"

// CreateTrustRequest generates a "aws/request.Request" representing the
// client's request for the CreateTrust operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 CreateTrust for more information on using the CreateTrust
// 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 CreateTrustRequest method.
//    req, resp := client.CreateTrustRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateTrust
func (c *DirectoryService) CreateTrustRequest(input *CreateTrustInput) (req *request.Request, output *CreateTrustOutput) {
	op := &request.Operation{
		Name:       opCreateTrust,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateTrustInput{}
	}

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

// CreateTrust API operation for AWS Directory Service.
//
// AWS Directory Service for Microsoft Active Directory allows you to configure
// trust relationships. For example, you can establish a trust between your
// Microsoft AD in the AWS cloud, and your existing on-premises Microsoft Active
// Directory. This would allow you to provide users and groups access to resources
// in either domain, with a single set of credentials.
//
// This action initiates the creation of the AWS side of a trust relationship
// between a Microsoft AD in the AWS cloud and an external 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 AWS Directory Service's
// API operation CreateTrust for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExistsException"
//   The specified entity already exists.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/CreateTrust
func (c *DirectoryService) CreateTrust(input *CreateTrustInput) (*CreateTrustOutput, error) {
	req, out := c.CreateTrustRequest(input)
	return out, req.Send()
}

// CreateTrustWithContext is the same as CreateTrust with the addition of
// the ability to pass a context and additional request options.
//
// See CreateTrust 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 *DirectoryService) CreateTrustWithContext(ctx aws.Context, input *CreateTrustInput, opts ...request.Option) (*CreateTrustOutput, error) {
	req, out := c.CreateTrustRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteConditionalForwarder = "DeleteConditionalForwarder"

// DeleteConditionalForwarderRequest generates a "aws/request.Request" representing the
// client's request for the DeleteConditionalForwarder operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DeleteConditionalForwarder for more information on using the DeleteConditionalForwarder
// 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 DeleteConditionalForwarderRequest method.
//    req, resp := client.DeleteConditionalForwarderRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeleteConditionalForwarder
func (c *DirectoryService) DeleteConditionalForwarderRequest(input *DeleteConditionalForwarderInput) (req *request.Request, output *DeleteConditionalForwarderOutput) {
	op := &request.Operation{
		Name:       opDeleteConditionalForwarder,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteConditionalForwarderInput{}
	}

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

// DeleteConditionalForwarder API operation for AWS Directory Service.
//
// Deletes a conditional forwarder that has been set up for your AWS directory.
//
// 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 AWS Directory Service's
// API operation DeleteConditionalForwarder for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeleteConditionalForwarder
func (c *DirectoryService) DeleteConditionalForwarder(input *DeleteConditionalForwarderInput) (*DeleteConditionalForwarderOutput, error) {
	req, out := c.DeleteConditionalForwarderRequest(input)
	return out, req.Send()
}

// DeleteConditionalForwarderWithContext is the same as DeleteConditionalForwarder with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteConditionalForwarder 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 *DirectoryService) DeleteConditionalForwarderWithContext(ctx aws.Context, input *DeleteConditionalForwarderInput, opts ...request.Option) (*DeleteConditionalForwarderOutput, error) {
	req, out := c.DeleteConditionalForwarderRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteDirectory = "DeleteDirectory"

// DeleteDirectoryRequest generates a "aws/request.Request" representing the
// client's request for the DeleteDirectory operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DeleteDirectory for more information on using the DeleteDirectory
// 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 DeleteDirectoryRequest method.
//    req, resp := client.DeleteDirectoryRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeleteDirectory
func (c *DirectoryService) DeleteDirectoryRequest(input *DeleteDirectoryInput) (req *request.Request, output *DeleteDirectoryOutput) {
	op := &request.Operation{
		Name:       opDeleteDirectory,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteDirectoryInput{}
	}

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

// DeleteDirectory API operation for AWS Directory Service.
//
// Deletes an AWS Directory Service directory.
//
// Before you call DeleteDirectory, ensure that all of the required permissions
// have been explicitly granted through a policy. For details about what permissions
// are required to run the DeleteDirectory operation, see AWS Directory Service
// API Permissions: Actions, Resources, and Conditions Reference (http://docs.aws.amazon.com/directoryservice/latest/admin-guide/UsingWithDS_IAM_ResourcePermissions.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for AWS Directory Service's
// API operation DeleteDirectory for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeleteDirectory
func (c *DirectoryService) DeleteDirectory(input *DeleteDirectoryInput) (*DeleteDirectoryOutput, error) {
	req, out := c.DeleteDirectoryRequest(input)
	return out, req.Send()
}

// DeleteDirectoryWithContext is the same as DeleteDirectory with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteDirectory 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 *DirectoryService) DeleteDirectoryWithContext(ctx aws.Context, input *DeleteDirectoryInput, opts ...request.Option) (*DeleteDirectoryOutput, error) {
	req, out := c.DeleteDirectoryRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteSnapshot = "DeleteSnapshot"

// DeleteSnapshotRequest generates a "aws/request.Request" representing the
// client's request for the DeleteSnapshot operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DeleteSnapshot for more information on using the DeleteSnapshot
// 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 DeleteSnapshotRequest method.
//    req, resp := client.DeleteSnapshotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeleteSnapshot
func (c *DirectoryService) DeleteSnapshotRequest(input *DeleteSnapshotInput) (req *request.Request, output *DeleteSnapshotOutput) {
	op := &request.Operation{
		Name:       opDeleteSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteSnapshotInput{}
	}

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

// DeleteSnapshot API operation for AWS Directory Service.
//
// Deletes a directory snapshot.
//
// 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 AWS Directory Service's
// API operation DeleteSnapshot for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeleteSnapshot
func (c *DirectoryService) DeleteSnapshot(input *DeleteSnapshotInput) (*DeleteSnapshotOutput, error) {
	req, out := c.DeleteSnapshotRequest(input)
	return out, req.Send()
}

// DeleteSnapshotWithContext is the same as DeleteSnapshot with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteSnapshot 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 *DirectoryService) DeleteSnapshotWithContext(ctx aws.Context, input *DeleteSnapshotInput, opts ...request.Option) (*DeleteSnapshotOutput, error) {
	req, out := c.DeleteSnapshotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeleteTrust = "DeleteTrust"

// DeleteTrustRequest generates a "aws/request.Request" representing the
// client's request for the DeleteTrust operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DeleteTrust for more information on using the DeleteTrust
// 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 DeleteTrustRequest method.
//    req, resp := client.DeleteTrustRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeleteTrust
func (c *DirectoryService) DeleteTrustRequest(input *DeleteTrustInput) (req *request.Request, output *DeleteTrustOutput) {
	op := &request.Operation{
		Name:       opDeleteTrust,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteTrustInput{}
	}

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

// DeleteTrust API operation for AWS Directory Service.
//
// Deletes an existing trust relationship between your Microsoft AD in the AWS
// cloud and an external 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 AWS Directory Service's
// API operation DeleteTrust for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeleteTrust
func (c *DirectoryService) DeleteTrust(input *DeleteTrustInput) (*DeleteTrustOutput, error) {
	req, out := c.DeleteTrustRequest(input)
	return out, req.Send()
}

// DeleteTrustWithContext is the same as DeleteTrust with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteTrust 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 *DirectoryService) DeleteTrustWithContext(ctx aws.Context, input *DeleteTrustInput, opts ...request.Option) (*DeleteTrustOutput, error) {
	req, out := c.DeleteTrustRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDeregisterEventTopic = "DeregisterEventTopic"

// DeregisterEventTopicRequest generates a "aws/request.Request" representing the
// client's request for the DeregisterEventTopic operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DeregisterEventTopic for more information on using the DeregisterEventTopic
// 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 DeregisterEventTopicRequest method.
//    req, resp := client.DeregisterEventTopicRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeregisterEventTopic
func (c *DirectoryService) DeregisterEventTopicRequest(input *DeregisterEventTopicInput) (req *request.Request, output *DeregisterEventTopicOutput) {
	op := &request.Operation{
		Name:       opDeregisterEventTopic,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeregisterEventTopicInput{}
	}

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

// DeregisterEventTopic API operation for AWS Directory Service.
//
// Removes the specified directory as a publisher to the specified SNS topic.
//
// 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 AWS Directory Service's
// API operation DeregisterEventTopic for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DeregisterEventTopic
func (c *DirectoryService) DeregisterEventTopic(input *DeregisterEventTopicInput) (*DeregisterEventTopicOutput, error) {
	req, out := c.DeregisterEventTopicRequest(input)
	return out, req.Send()
}

// DeregisterEventTopicWithContext is the same as DeregisterEventTopic with the addition of
// the ability to pass a context and additional request options.
//
// See DeregisterEventTopic 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 *DirectoryService) DeregisterEventTopicWithContext(ctx aws.Context, input *DeregisterEventTopicInput, opts ...request.Option) (*DeregisterEventTopicOutput, error) {
	req, out := c.DeregisterEventTopicRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeConditionalForwarders = "DescribeConditionalForwarders"

// DescribeConditionalForwardersRequest generates a "aws/request.Request" representing the
// client's request for the DescribeConditionalForwarders operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DescribeConditionalForwarders for more information on using the DescribeConditionalForwarders
// 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 DescribeConditionalForwardersRequest method.
//    req, resp := client.DescribeConditionalForwardersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeConditionalForwarders
func (c *DirectoryService) DescribeConditionalForwardersRequest(input *DescribeConditionalForwardersInput) (req *request.Request, output *DescribeConditionalForwardersOutput) {
	op := &request.Operation{
		Name:       opDescribeConditionalForwarders,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeConditionalForwardersInput{}
	}

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

// DescribeConditionalForwarders API operation for AWS Directory Service.
//
// Obtains information about the conditional forwarders for this account.
//
// If no input parameters are provided for RemoteDomainNames, this request describes
// all conditional forwarders for the specified directory ID.
//
// 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 AWS Directory Service's
// API operation DescribeConditionalForwarders for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeConditionalForwarders
func (c *DirectoryService) DescribeConditionalForwarders(input *DescribeConditionalForwardersInput) (*DescribeConditionalForwardersOutput, error) {
	req, out := c.DescribeConditionalForwardersRequest(input)
	return out, req.Send()
}

// DescribeConditionalForwardersWithContext is the same as DescribeConditionalForwarders with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeConditionalForwarders 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 *DirectoryService) DescribeConditionalForwardersWithContext(ctx aws.Context, input *DescribeConditionalForwardersInput, opts ...request.Option) (*DescribeConditionalForwardersOutput, error) {
	req, out := c.DescribeConditionalForwardersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeDirectories = "DescribeDirectories"

// DescribeDirectoriesRequest generates a "aws/request.Request" representing the
// client's request for the DescribeDirectories operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DescribeDirectories for more information on using the DescribeDirectories
// 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 DescribeDirectoriesRequest method.
//    req, resp := client.DescribeDirectoriesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeDirectories
func (c *DirectoryService) DescribeDirectoriesRequest(input *DescribeDirectoriesInput) (req *request.Request, output *DescribeDirectoriesOutput) {
	op := &request.Operation{
		Name:       opDescribeDirectories,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeDirectoriesInput{}
	}

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

// DescribeDirectories API operation for AWS Directory Service.
//
// Obtains information about the directories that belong to this account.
//
// You can retrieve information about specific directories by passing the directory
// identifiers in the DirectoryIds parameter. Otherwise, all directories that
// belong to the current account are returned.
//
// This operation supports pagination with the use of the NextToken request
// and response parameters. If more results are available, the DescribeDirectoriesResult.NextToken
// member contains a token that you pass in the next call to DescribeDirectories
// to retrieve the next set of items.
//
// You can also specify a maximum number of return results with the Limit parameter.
//
// 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 AWS Directory Service's
// API operation DescribeDirectories for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
//   The NextToken value is not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeDirectories
func (c *DirectoryService) DescribeDirectories(input *DescribeDirectoriesInput) (*DescribeDirectoriesOutput, error) {
	req, out := c.DescribeDirectoriesRequest(input)
	return out, req.Send()
}

// DescribeDirectoriesWithContext is the same as DescribeDirectories with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeDirectories 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 *DirectoryService) DescribeDirectoriesWithContext(ctx aws.Context, input *DescribeDirectoriesInput, opts ...request.Option) (*DescribeDirectoriesOutput, error) {
	req, out := c.DescribeDirectoriesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeDomainControllers = "DescribeDomainControllers"

// DescribeDomainControllersRequest generates a "aws/request.Request" representing the
// client's request for the DescribeDomainControllers operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DescribeDomainControllers for more information on using the DescribeDomainControllers
// 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 DescribeDomainControllersRequest method.
//    req, resp := client.DescribeDomainControllersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeDomainControllers
func (c *DirectoryService) DescribeDomainControllersRequest(input *DescribeDomainControllersInput) (req *request.Request, output *DescribeDomainControllersOutput) {
	op := &request.Operation{
		Name:       opDescribeDomainControllers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &request.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "Limit",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &DescribeDomainControllersInput{}
	}

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

// DescribeDomainControllers API operation for AWS Directory Service.
//
// Provides information about any domain controllers in your directory.
//
// 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 AWS Directory Service's
// API operation DescribeDomainControllers for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
//   The NextToken value is not valid.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeDomainControllers
func (c *DirectoryService) DescribeDomainControllers(input *DescribeDomainControllersInput) (*DescribeDomainControllersOutput, error) {
	req, out := c.DescribeDomainControllersRequest(input)
	return out, req.Send()
}

// DescribeDomainControllersWithContext is the same as DescribeDomainControllers with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeDomainControllers 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 *DirectoryService) DescribeDomainControllersWithContext(ctx aws.Context, input *DescribeDomainControllersInput, opts ...request.Option) (*DescribeDomainControllersOutput, error) {
	req, out := c.DescribeDomainControllersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// DescribeDomainControllersPages iterates over the pages of a DescribeDomainControllers operation,
// calling the "fn" function with the response data for each page. To stop
// iterating, return false from the fn function.
//
// See DescribeDomainControllers 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 DescribeDomainControllers operation.
//    pageNum := 0
//    err := client.DescribeDomainControllersPages(params,
//        func(page *DescribeDomainControllersOutput, lastPage bool) bool {
//            pageNum++
//            fmt.Println(page)
//            return pageNum <= 3
//        })
//
func (c *DirectoryService) DescribeDomainControllersPages(input *DescribeDomainControllersInput, fn func(*DescribeDomainControllersOutput, bool) bool) error {
	return c.DescribeDomainControllersPagesWithContext(aws.BackgroundContext(), input, fn)
}

// DescribeDomainControllersPagesWithContext same as DescribeDomainControllersPages 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 *DirectoryService) DescribeDomainControllersPagesWithContext(ctx aws.Context, input *DescribeDomainControllersInput, fn func(*DescribeDomainControllersOutput, bool) bool, opts ...request.Option) error {
	p := request.Pagination{
		NewRequest: func() (*request.Request, error) {
			var inCpy *DescribeDomainControllersInput
			if input != nil {
				tmp := *input
				inCpy = &tmp
			}
			req, _ := c.DescribeDomainControllersRequest(inCpy)
			req.SetContext(ctx)
			req.ApplyOptions(opts...)
			return req, nil
		},
	}

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

const opDescribeEventTopics = "DescribeEventTopics"

// DescribeEventTopicsRequest generates a "aws/request.Request" representing the
// client's request for the DescribeEventTopics operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DescribeEventTopics for more information on using the DescribeEventTopics
// 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 DescribeEventTopicsRequest method.
//    req, resp := client.DescribeEventTopicsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeEventTopics
func (c *DirectoryService) DescribeEventTopicsRequest(input *DescribeEventTopicsInput) (req *request.Request, output *DescribeEventTopicsOutput) {
	op := &request.Operation{
		Name:       opDescribeEventTopics,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeEventTopicsInput{}
	}

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

// DescribeEventTopics API operation for AWS Directory Service.
//
// Obtains information about which SNS topics receive status messages from the
// specified directory.
//
// If no input parameters are provided, such as DirectoryId or TopicName, this
// request describes all of the associations in the 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 AWS Directory Service's
// API operation DescribeEventTopics for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeEventTopics
func (c *DirectoryService) DescribeEventTopics(input *DescribeEventTopicsInput) (*DescribeEventTopicsOutput, error) {
	req, out := c.DescribeEventTopicsRequest(input)
	return out, req.Send()
}

// DescribeEventTopicsWithContext is the same as DescribeEventTopics with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeEventTopics 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 *DirectoryService) DescribeEventTopicsWithContext(ctx aws.Context, input *DescribeEventTopicsInput, opts ...request.Option) (*DescribeEventTopicsOutput, error) {
	req, out := c.DescribeEventTopicsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeSnapshots = "DescribeSnapshots"

// DescribeSnapshotsRequest generates a "aws/request.Request" representing the
// client's request for the DescribeSnapshots operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DescribeSnapshots for more information on using the DescribeSnapshots
// 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 DescribeSnapshotsRequest method.
//    req, resp := client.DescribeSnapshotsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeSnapshots
func (c *DirectoryService) DescribeSnapshotsRequest(input *DescribeSnapshotsInput) (req *request.Request, output *DescribeSnapshotsOutput) {
	op := &request.Operation{
		Name:       opDescribeSnapshots,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeSnapshotsInput{}
	}

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

// DescribeSnapshots API operation for AWS Directory Service.
//
// Obtains information about the directory snapshots that belong to this account.
//
// This operation supports pagination with the use of the NextToken request
// and response parameters. If more results are available, the DescribeSnapshots.NextToken
// member contains a token that you pass in the next call to DescribeSnapshots
// to retrieve the next set of items.
//
// You can also specify a maximum number of return results with the Limit parameter.
//
// 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 AWS Directory Service's
// API operation DescribeSnapshots for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
//   The NextToken value is not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeSnapshots
func (c *DirectoryService) DescribeSnapshots(input *DescribeSnapshotsInput) (*DescribeSnapshotsOutput, error) {
	req, out := c.DescribeSnapshotsRequest(input)
	return out, req.Send()
}

// DescribeSnapshotsWithContext is the same as DescribeSnapshots with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeSnapshots 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 *DirectoryService) DescribeSnapshotsWithContext(ctx aws.Context, input *DescribeSnapshotsInput, opts ...request.Option) (*DescribeSnapshotsOutput, error) {
	req, out := c.DescribeSnapshotsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDescribeTrusts = "DescribeTrusts"

// DescribeTrustsRequest generates a "aws/request.Request" representing the
// client's request for the DescribeTrusts operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DescribeTrusts for more information on using the DescribeTrusts
// 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 DescribeTrustsRequest method.
//    req, resp := client.DescribeTrustsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeTrusts
func (c *DirectoryService) DescribeTrustsRequest(input *DescribeTrustsInput) (req *request.Request, output *DescribeTrustsOutput) {
	op := &request.Operation{
		Name:       opDescribeTrusts,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeTrustsInput{}
	}

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

// DescribeTrusts API operation for AWS Directory Service.
//
// Obtains information about the trust relationships for this account.
//
// If no input parameters are provided, such as DirectoryId or TrustIds, this
// request describes all the trust relationships belonging to the 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 AWS Directory Service's
// API operation DescribeTrusts for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
//   The NextToken value is not valid.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DescribeTrusts
func (c *DirectoryService) DescribeTrusts(input *DescribeTrustsInput) (*DescribeTrustsOutput, error) {
	req, out := c.DescribeTrustsRequest(input)
	return out, req.Send()
}

// DescribeTrustsWithContext is the same as DescribeTrusts with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeTrusts 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 *DirectoryService) DescribeTrustsWithContext(ctx aws.Context, input *DescribeTrustsInput, opts ...request.Option) (*DescribeTrustsOutput, error) {
	req, out := c.DescribeTrustsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDisableRadius = "DisableRadius"

// DisableRadiusRequest generates a "aws/request.Request" representing the
// client's request for the DisableRadius operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DisableRadius for more information on using the DisableRadius
// 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 DisableRadiusRequest method.
//    req, resp := client.DisableRadiusRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DisableRadius
func (c *DirectoryService) DisableRadiusRequest(input *DisableRadiusInput) (req *request.Request, output *DisableRadiusOutput) {
	op := &request.Operation{
		Name:       opDisableRadius,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisableRadiusInput{}
	}

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

// DisableRadius API operation for AWS Directory Service.
//
// Disables multi-factor authentication (MFA) with the Remote Authentication
// Dial In User Service (RADIUS) server for an AD Connector directory.
//
// 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 AWS Directory Service's
// API operation DisableRadius for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DisableRadius
func (c *DirectoryService) DisableRadius(input *DisableRadiusInput) (*DisableRadiusOutput, error) {
	req, out := c.DisableRadiusRequest(input)
	return out, req.Send()
}

// DisableRadiusWithContext is the same as DisableRadius with the addition of
// the ability to pass a context and additional request options.
//
// See DisableRadius 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 *DirectoryService) DisableRadiusWithContext(ctx aws.Context, input *DisableRadiusInput, opts ...request.Option) (*DisableRadiusOutput, error) {
	req, out := c.DisableRadiusRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDisableSso = "DisableSso"

// DisableSsoRequest generates a "aws/request.Request" representing the
// client's request for the DisableSso operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 DisableSso for more information on using the DisableSso
// 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 DisableSsoRequest method.
//    req, resp := client.DisableSsoRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DisableSso
func (c *DirectoryService) DisableSsoRequest(input *DisableSsoInput) (req *request.Request, output *DisableSsoOutput) {
	op := &request.Operation{
		Name:       opDisableSso,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisableSsoInput{}
	}

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

// DisableSso API operation for AWS Directory Service.
//
// Disables single-sign on for a directory.
//
// 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 AWS Directory Service's
// API operation DisableSso for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInsufficientPermissionsException "InsufficientPermissionsException"
//   The account does not have sufficient permission to perform the operation.
//
//   * ErrCodeAuthenticationFailedException "AuthenticationFailedException"
//   An authentication error occurred.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/DisableSso
func (c *DirectoryService) DisableSso(input *DisableSsoInput) (*DisableSsoOutput, error) {
	req, out := c.DisableSsoRequest(input)
	return out, req.Send()
}

// DisableSsoWithContext is the same as DisableSso with the addition of
// the ability to pass a context and additional request options.
//
// See DisableSso 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 *DirectoryService) DisableSsoWithContext(ctx aws.Context, input *DisableSsoInput, opts ...request.Option) (*DisableSsoOutput, error) {
	req, out := c.DisableSsoRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opEnableRadius = "EnableRadius"

// EnableRadiusRequest generates a "aws/request.Request" representing the
// client's request for the EnableRadius operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 EnableRadius for more information on using the EnableRadius
// 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 EnableRadiusRequest method.
//    req, resp := client.EnableRadiusRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/EnableRadius
func (c *DirectoryService) EnableRadiusRequest(input *EnableRadiusInput) (req *request.Request, output *EnableRadiusOutput) {
	op := &request.Operation{
		Name:       opEnableRadius,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &EnableRadiusInput{}
	}

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

// EnableRadius API operation for AWS Directory Service.
//
// Enables multi-factor authentication (MFA) with the Remote Authentication
// Dial In User Service (RADIUS) server for an AD Connector directory.
//
// 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 AWS Directory Service's
// API operation EnableRadius for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExistsException"
//   The specified entity already exists.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/EnableRadius
func (c *DirectoryService) EnableRadius(input *EnableRadiusInput) (*EnableRadiusOutput, error) {
	req, out := c.EnableRadiusRequest(input)
	return out, req.Send()
}

// EnableRadiusWithContext is the same as EnableRadius with the addition of
// the ability to pass a context and additional request options.
//
// See EnableRadius 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 *DirectoryService) EnableRadiusWithContext(ctx aws.Context, input *EnableRadiusInput, opts ...request.Option) (*EnableRadiusOutput, error) {
	req, out := c.EnableRadiusRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opEnableSso = "EnableSso"

// EnableSsoRequest generates a "aws/request.Request" representing the
// client's request for the EnableSso operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 EnableSso for more information on using the EnableSso
// 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 EnableSsoRequest method.
//    req, resp := client.EnableSsoRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/EnableSso
func (c *DirectoryService) EnableSsoRequest(input *EnableSsoInput) (req *request.Request, output *EnableSsoOutput) {
	op := &request.Operation{
		Name:       opEnableSso,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &EnableSsoInput{}
	}

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

// EnableSso API operation for AWS Directory Service.
//
// Enables single sign-on for a directory.
//
// 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 AWS Directory Service's
// API operation EnableSso for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInsufficientPermissionsException "InsufficientPermissionsException"
//   The account does not have sufficient permission to perform the operation.
//
//   * ErrCodeAuthenticationFailedException "AuthenticationFailedException"
//   An authentication error occurred.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/EnableSso
func (c *DirectoryService) EnableSso(input *EnableSsoInput) (*EnableSsoOutput, error) {
	req, out := c.EnableSsoRequest(input)
	return out, req.Send()
}

// EnableSsoWithContext is the same as EnableSso with the addition of
// the ability to pass a context and additional request options.
//
// See EnableSso 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 *DirectoryService) EnableSsoWithContext(ctx aws.Context, input *EnableSsoInput, opts ...request.Option) (*EnableSsoOutput, error) {
	req, out := c.EnableSsoRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opGetDirectoryLimits = "GetDirectoryLimits"

// GetDirectoryLimitsRequest generates a "aws/request.Request" representing the
// client's request for the GetDirectoryLimits operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 GetDirectoryLimits for more information on using the GetDirectoryLimits
// 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 GetDirectoryLimitsRequest method.
//    req, resp := client.GetDirectoryLimitsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/GetDirectoryLimits
func (c *DirectoryService) GetDirectoryLimitsRequest(input *GetDirectoryLimitsInput) (req *request.Request, output *GetDirectoryLimitsOutput) {
	op := &request.Operation{
		Name:       opGetDirectoryLimits,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetDirectoryLimitsInput{}
	}

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

// GetDirectoryLimits API operation for AWS Directory Service.
//
// Obtains directory limit information for the current region.
//
// 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 AWS Directory Service's
// API operation GetDirectoryLimits for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/GetDirectoryLimits
func (c *DirectoryService) GetDirectoryLimits(input *GetDirectoryLimitsInput) (*GetDirectoryLimitsOutput, error) {
	req, out := c.GetDirectoryLimitsRequest(input)
	return out, req.Send()
}

// GetDirectoryLimitsWithContext is the same as GetDirectoryLimits with the addition of
// the ability to pass a context and additional request options.
//
// See GetDirectoryLimits 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 *DirectoryService) GetDirectoryLimitsWithContext(ctx aws.Context, input *GetDirectoryLimitsInput, opts ...request.Option) (*GetDirectoryLimitsOutput, error) {
	req, out := c.GetDirectoryLimitsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opGetSnapshotLimits = "GetSnapshotLimits"

// GetSnapshotLimitsRequest generates a "aws/request.Request" representing the
// client's request for the GetSnapshotLimits operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 GetSnapshotLimits for more information on using the GetSnapshotLimits
// 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 GetSnapshotLimitsRequest method.
//    req, resp := client.GetSnapshotLimitsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/GetSnapshotLimits
func (c *DirectoryService) GetSnapshotLimitsRequest(input *GetSnapshotLimitsInput) (req *request.Request, output *GetSnapshotLimitsOutput) {
	op := &request.Operation{
		Name:       opGetSnapshotLimits,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetSnapshotLimitsInput{}
	}

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

// GetSnapshotLimits API operation for AWS Directory Service.
//
// Obtains the manual snapshot limits for a directory.
//
// 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 AWS Directory Service's
// API operation GetSnapshotLimits for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/GetSnapshotLimits
func (c *DirectoryService) GetSnapshotLimits(input *GetSnapshotLimitsInput) (*GetSnapshotLimitsOutput, error) {
	req, out := c.GetSnapshotLimitsRequest(input)
	return out, req.Send()
}

// GetSnapshotLimitsWithContext is the same as GetSnapshotLimits with the addition of
// the ability to pass a context and additional request options.
//
// See GetSnapshotLimits 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 *DirectoryService) GetSnapshotLimitsWithContext(ctx aws.Context, input *GetSnapshotLimitsInput, opts ...request.Option) (*GetSnapshotLimitsOutput, error) {
	req, out := c.GetSnapshotLimitsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opListIpRoutes = "ListIpRoutes"

// ListIpRoutesRequest generates a "aws/request.Request" representing the
// client's request for the ListIpRoutes operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 ListIpRoutes for more information on using the ListIpRoutes
// 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 ListIpRoutesRequest method.
//    req, resp := client.ListIpRoutesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ListIpRoutes
func (c *DirectoryService) ListIpRoutesRequest(input *ListIpRoutesInput) (req *request.Request, output *ListIpRoutesOutput) {
	op := &request.Operation{
		Name:       opListIpRoutes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListIpRoutesInput{}
	}

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

// ListIpRoutes API operation for AWS Directory Service.
//
// Lists the address blocks that you have added to a directory.
//
// 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 AWS Directory Service's
// API operation ListIpRoutes for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
//   The NextToken value is not valid.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ListIpRoutes
func (c *DirectoryService) ListIpRoutes(input *ListIpRoutesInput) (*ListIpRoutesOutput, error) {
	req, out := c.ListIpRoutesRequest(input)
	return out, req.Send()
}

// ListIpRoutesWithContext is the same as ListIpRoutes with the addition of
// the ability to pass a context and additional request options.
//
// See ListIpRoutes 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 *DirectoryService) ListIpRoutesWithContext(ctx aws.Context, input *ListIpRoutesInput, opts ...request.Option) (*ListIpRoutesOutput, error) {
	req, out := c.ListIpRoutesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opListSchemaExtensions = "ListSchemaExtensions"

// ListSchemaExtensionsRequest generates a "aws/request.Request" representing the
// client's request for the ListSchemaExtensions operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 ListSchemaExtensions for more information on using the ListSchemaExtensions
// 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 ListSchemaExtensionsRequest method.
//    req, resp := client.ListSchemaExtensionsRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ListSchemaExtensions
func (c *DirectoryService) ListSchemaExtensionsRequest(input *ListSchemaExtensionsInput) (req *request.Request, output *ListSchemaExtensionsOutput) {
	op := &request.Operation{
		Name:       opListSchemaExtensions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListSchemaExtensionsInput{}
	}

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

// ListSchemaExtensions API operation for AWS Directory Service.
//
// Lists all schema extensions applied to a Microsoft AD Directory.
//
// 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 AWS Directory Service's
// API operation ListSchemaExtensions for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
//   The NextToken value is not valid.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ListSchemaExtensions
func (c *DirectoryService) ListSchemaExtensions(input *ListSchemaExtensionsInput) (*ListSchemaExtensionsOutput, error) {
	req, out := c.ListSchemaExtensionsRequest(input)
	return out, req.Send()
}

// ListSchemaExtensionsWithContext is the same as ListSchemaExtensions with the addition of
// the ability to pass a context and additional request options.
//
// See ListSchemaExtensions 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 *DirectoryService) ListSchemaExtensionsWithContext(ctx aws.Context, input *ListSchemaExtensionsInput, opts ...request.Option) (*ListSchemaExtensionsOutput, error) {
	req, out := c.ListSchemaExtensionsRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opListTagsForResource = "ListTagsForResource"

// ListTagsForResourceRequest generates a "aws/request.Request" representing the
// client's request for the ListTagsForResource operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 ListTagsForResource for more information on using the ListTagsForResource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the ListTagsForResourceRequest method.
//    req, resp := client.ListTagsForResourceRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ListTagsForResource
func (c *DirectoryService) ListTagsForResourceRequest(input *ListTagsForResourceInput) (req *request.Request, output *ListTagsForResourceOutput) {
	op := &request.Operation{
		Name:       opListTagsForResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

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

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

// ListTagsForResource API operation for AWS Directory Service.
//
// Lists all tags on a directory.
//
// 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 AWS Directory Service's
// API operation ListTagsForResource for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidNextTokenException "InvalidNextTokenException"
//   The NextToken value is not valid.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ListTagsForResource
func (c *DirectoryService) ListTagsForResource(input *ListTagsForResourceInput) (*ListTagsForResourceOutput, error) {
	req, out := c.ListTagsForResourceRequest(input)
	return out, req.Send()
}

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

const opRegisterEventTopic = "RegisterEventTopic"

// RegisterEventTopicRequest generates a "aws/request.Request" representing the
// client's request for the RegisterEventTopic operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 RegisterEventTopic for more information on using the RegisterEventTopic
// 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 RegisterEventTopicRequest method.
//    req, resp := client.RegisterEventTopicRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/RegisterEventTopic
func (c *DirectoryService) RegisterEventTopicRequest(input *RegisterEventTopicInput) (req *request.Request, output *RegisterEventTopicOutput) {
	op := &request.Operation{
		Name:       opRegisterEventTopic,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RegisterEventTopicInput{}
	}

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

// RegisterEventTopic API operation for AWS Directory Service.
//
// Associates a directory with an SNS topic. This establishes the directory
// as a publisher to the specified SNS topic. You can then receive email or
// text (SMS) messages when the status of your directory changes. You get notified
// if your directory goes from an Active status to an Impaired or Inoperable
// status. You also receive a notification when the directory returns to an
// Active status.
//
// 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 AWS Directory Service's
// API operation RegisterEventTopic for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/RegisterEventTopic
func (c *DirectoryService) RegisterEventTopic(input *RegisterEventTopicInput) (*RegisterEventTopicOutput, error) {
	req, out := c.RegisterEventTopicRequest(input)
	return out, req.Send()
}

// RegisterEventTopicWithContext is the same as RegisterEventTopic with the addition of
// the ability to pass a context and additional request options.
//
// See RegisterEventTopic 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 *DirectoryService) RegisterEventTopicWithContext(ctx aws.Context, input *RegisterEventTopicInput, opts ...request.Option) (*RegisterEventTopicOutput, error) {
	req, out := c.RegisterEventTopicRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opRemoveIpRoutes = "RemoveIpRoutes"

// RemoveIpRoutesRequest generates a "aws/request.Request" representing the
// client's request for the RemoveIpRoutes operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 RemoveIpRoutes for more information on using the RemoveIpRoutes
// 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 RemoveIpRoutesRequest method.
//    req, resp := client.RemoveIpRoutesRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/RemoveIpRoutes
func (c *DirectoryService) RemoveIpRoutesRequest(input *RemoveIpRoutesInput) (req *request.Request, output *RemoveIpRoutesOutput) {
	op := &request.Operation{
		Name:       opRemoveIpRoutes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RemoveIpRoutesInput{}
	}

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

// RemoveIpRoutes API operation for AWS Directory Service.
//
// Removes IP address blocks from a directory.
//
// 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 AWS Directory Service's
// API operation RemoveIpRoutes for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/RemoveIpRoutes
func (c *DirectoryService) RemoveIpRoutes(input *RemoveIpRoutesInput) (*RemoveIpRoutesOutput, error) {
	req, out := c.RemoveIpRoutesRequest(input)
	return out, req.Send()
}

// RemoveIpRoutesWithContext is the same as RemoveIpRoutes with the addition of
// the ability to pass a context and additional request options.
//
// See RemoveIpRoutes 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 *DirectoryService) RemoveIpRoutesWithContext(ctx aws.Context, input *RemoveIpRoutesInput, opts ...request.Option) (*RemoveIpRoutesOutput, error) {
	req, out := c.RemoveIpRoutesRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opRemoveTagsFromResource = "RemoveTagsFromResource"

// RemoveTagsFromResourceRequest generates a "aws/request.Request" representing the
// client's request for the RemoveTagsFromResource operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 RemoveTagsFromResource for more information on using the RemoveTagsFromResource
// 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 RemoveTagsFromResourceRequest method.
//    req, resp := client.RemoveTagsFromResourceRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/RemoveTagsFromResource
func (c *DirectoryService) RemoveTagsFromResourceRequest(input *RemoveTagsFromResourceInput) (req *request.Request, output *RemoveTagsFromResourceOutput) {
	op := &request.Operation{
		Name:       opRemoveTagsFromResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RemoveTagsFromResourceInput{}
	}

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

// RemoveTagsFromResource API operation for AWS Directory Service.
//
// Removes tags from a directory.
//
// 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 AWS Directory Service's
// API operation RemoveTagsFromResource for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/RemoveTagsFromResource
func (c *DirectoryService) RemoveTagsFromResource(input *RemoveTagsFromResourceInput) (*RemoveTagsFromResourceOutput, error) {
	req, out := c.RemoveTagsFromResourceRequest(input)
	return out, req.Send()
}

// RemoveTagsFromResourceWithContext is the same as RemoveTagsFromResource with the addition of
// the ability to pass a context and additional request options.
//
// See RemoveTagsFromResource 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 *DirectoryService) RemoveTagsFromResourceWithContext(ctx aws.Context, input *RemoveTagsFromResourceInput, opts ...request.Option) (*RemoveTagsFromResourceOutput, error) {
	req, out := c.RemoveTagsFromResourceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opResetUserPassword = "ResetUserPassword"

// ResetUserPasswordRequest generates a "aws/request.Request" representing the
// client's request for the ResetUserPassword operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 ResetUserPassword for more information on using the ResetUserPassword
// 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 ResetUserPasswordRequest method.
//    req, resp := client.ResetUserPasswordRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ResetUserPassword
func (c *DirectoryService) ResetUserPasswordRequest(input *ResetUserPasswordInput) (req *request.Request, output *ResetUserPasswordOutput) {
	op := &request.Operation{
		Name:       opResetUserPassword,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ResetUserPasswordInput{}
	}

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

// ResetUserPassword API operation for AWS Directory Service.
//
// Resets the password for any user in your AWS Managed Microsoft AD or Simple
// AD directory.
//
// 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 AWS Directory Service's
// API operation ResetUserPassword for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeUserDoesNotExistException "UserDoesNotExistException"
//   The user provided a username that does not exist in your directory.
//
//   * ErrCodeInvalidPasswordException "InvalidPasswordException"
//   The new password provided by the user does not meet the password complexity
//   requirements defined in your directory.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/ResetUserPassword
func (c *DirectoryService) ResetUserPassword(input *ResetUserPasswordInput) (*ResetUserPasswordOutput, error) {
	req, out := c.ResetUserPasswordRequest(input)
	return out, req.Send()
}

// ResetUserPasswordWithContext is the same as ResetUserPassword with the addition of
// the ability to pass a context and additional request options.
//
// See ResetUserPassword 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 *DirectoryService) ResetUserPasswordWithContext(ctx aws.Context, input *ResetUserPasswordInput, opts ...request.Option) (*ResetUserPasswordOutput, error) {
	req, out := c.ResetUserPasswordRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opRestoreFromSnapshot = "RestoreFromSnapshot"

// RestoreFromSnapshotRequest generates a "aws/request.Request" representing the
// client's request for the RestoreFromSnapshot operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 RestoreFromSnapshot for more information on using the RestoreFromSnapshot
// 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 RestoreFromSnapshotRequest method.
//    req, resp := client.RestoreFromSnapshotRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/RestoreFromSnapshot
func (c *DirectoryService) RestoreFromSnapshotRequest(input *RestoreFromSnapshotInput) (req *request.Request, output *RestoreFromSnapshotOutput) {
	op := &request.Operation{
		Name:       opRestoreFromSnapshot,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RestoreFromSnapshotInput{}
	}

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

// RestoreFromSnapshot API operation for AWS Directory Service.
//
// Restores a directory using an existing directory snapshot.
//
// When you restore a directory from a snapshot, any changes made to the directory
// after the snapshot date are overwritten.
//
// This action returns as soon as the restore operation is initiated. You can
// monitor the progress of the restore operation by calling the DescribeDirectories
// operation with the directory identifier. When the DirectoryDescription.Stage
// value changes to Active, the restore operation is 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 AWS Directory Service's
// API operation RestoreFromSnapshot for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/RestoreFromSnapshot
func (c *DirectoryService) RestoreFromSnapshot(input *RestoreFromSnapshotInput) (*RestoreFromSnapshotOutput, error) {
	req, out := c.RestoreFromSnapshotRequest(input)
	return out, req.Send()
}

// RestoreFromSnapshotWithContext is the same as RestoreFromSnapshot with the addition of
// the ability to pass a context and additional request options.
//
// See RestoreFromSnapshot 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 *DirectoryService) RestoreFromSnapshotWithContext(ctx aws.Context, input *RestoreFromSnapshotInput, opts ...request.Option) (*RestoreFromSnapshotOutput, error) {
	req, out := c.RestoreFromSnapshotRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opStartSchemaExtension = "StartSchemaExtension"

// StartSchemaExtensionRequest generates a "aws/request.Request" representing the
// client's request for the StartSchemaExtension operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 StartSchemaExtension for more information on using the StartSchemaExtension
// 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 StartSchemaExtensionRequest method.
//    req, resp := client.StartSchemaExtensionRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/StartSchemaExtension
func (c *DirectoryService) StartSchemaExtensionRequest(input *StartSchemaExtensionInput) (req *request.Request, output *StartSchemaExtensionOutput) {
	op := &request.Operation{
		Name:       opStartSchemaExtension,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartSchemaExtensionInput{}
	}

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

// StartSchemaExtension API operation for AWS Directory Service.
//
// Applies a schema extension to a Microsoft AD directory.
//
// 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 AWS Directory Service's
// API operation StartSchemaExtension for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeSnapshotLimitExceededException "SnapshotLimitExceededException"
//   The maximum number of manual snapshots for the directory has been reached.
//   You can use the GetSnapshotLimits operation to determine the snapshot limits
//   for a directory.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/StartSchemaExtension
func (c *DirectoryService) StartSchemaExtension(input *StartSchemaExtensionInput) (*StartSchemaExtensionOutput, error) {
	req, out := c.StartSchemaExtensionRequest(input)
	return out, req.Send()
}

// StartSchemaExtensionWithContext is the same as StartSchemaExtension with the addition of
// the ability to pass a context and additional request options.
//
// See StartSchemaExtension 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 *DirectoryService) StartSchemaExtensionWithContext(ctx aws.Context, input *StartSchemaExtensionInput, opts ...request.Option) (*StartSchemaExtensionOutput, error) {
	req, out := c.StartSchemaExtensionRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateConditionalForwarder = "UpdateConditionalForwarder"

// UpdateConditionalForwarderRequest generates a "aws/request.Request" representing the
// client's request for the UpdateConditionalForwarder operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 UpdateConditionalForwarder for more information on using the UpdateConditionalForwarder
// 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 UpdateConditionalForwarderRequest method.
//    req, resp := client.UpdateConditionalForwarderRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/UpdateConditionalForwarder
func (c *DirectoryService) UpdateConditionalForwarderRequest(input *UpdateConditionalForwarderInput) (req *request.Request, output *UpdateConditionalForwarderOutput) {
	op := &request.Operation{
		Name:       opUpdateConditionalForwarder,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateConditionalForwarderInput{}
	}

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

// UpdateConditionalForwarder API operation for AWS Directory Service.
//
// Updates a conditional forwarder that has been set up for your AWS directory.
//
// 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 AWS Directory Service's
// API operation UpdateConditionalForwarder for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/UpdateConditionalForwarder
func (c *DirectoryService) UpdateConditionalForwarder(input *UpdateConditionalForwarderInput) (*UpdateConditionalForwarderOutput, error) {
	req, out := c.UpdateConditionalForwarderRequest(input)
	return out, req.Send()
}

// UpdateConditionalForwarderWithContext is the same as UpdateConditionalForwarder with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateConditionalForwarder 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 *DirectoryService) UpdateConditionalForwarderWithContext(ctx aws.Context, input *UpdateConditionalForwarderInput, opts ...request.Option) (*UpdateConditionalForwarderOutput, error) {
	req, out := c.UpdateConditionalForwarderRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateNumberOfDomainControllers = "UpdateNumberOfDomainControllers"

// UpdateNumberOfDomainControllersRequest generates a "aws/request.Request" representing the
// client's request for the UpdateNumberOfDomainControllers operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 UpdateNumberOfDomainControllers for more information on using the UpdateNumberOfDomainControllers
// 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 UpdateNumberOfDomainControllersRequest method.
//    req, resp := client.UpdateNumberOfDomainControllersRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/UpdateNumberOfDomainControllers
func (c *DirectoryService) UpdateNumberOfDomainControllersRequest(input *UpdateNumberOfDomainControllersInput) (req *request.Request, output *UpdateNumberOfDomainControllersOutput) {
	op := &request.Operation{
		Name:       opUpdateNumberOfDomainControllers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateNumberOfDomainControllersInput{}
	}

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

// UpdateNumberOfDomainControllers API operation for AWS Directory Service.
//
// Adds or removes domain controllers to or from the directory. Based on the
// difference between current value and new value (provided through this API
// call), domain controllers will be added or removed. It may take up to 45
// minutes for any new domain controllers to become fully active once the requested
// number of domain controllers is updated. During this time, you cannot make
// another update request.
//
// 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 AWS Directory Service's
// API operation UpdateNumberOfDomainControllers for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeDirectoryUnavailableException "DirectoryUnavailableException"
//   The specified directory is unavailable or could not be found.
//
//   * ErrCodeDomainControllerLimitExceededException "DomainControllerLimitExceededException"
//   The maximum allowed number of domain controllers per directory was exceeded.
//   The default limit per directory is 20 domain controllers.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/UpdateNumberOfDomainControllers
func (c *DirectoryService) UpdateNumberOfDomainControllers(input *UpdateNumberOfDomainControllersInput) (*UpdateNumberOfDomainControllersOutput, error) {
	req, out := c.UpdateNumberOfDomainControllersRequest(input)
	return out, req.Send()
}

// UpdateNumberOfDomainControllersWithContext is the same as UpdateNumberOfDomainControllers with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateNumberOfDomainControllers 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 *DirectoryService) UpdateNumberOfDomainControllersWithContext(ctx aws.Context, input *UpdateNumberOfDomainControllersInput, opts ...request.Option) (*UpdateNumberOfDomainControllersOutput, error) {
	req, out := c.UpdateNumberOfDomainControllersRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opUpdateRadius = "UpdateRadius"

// UpdateRadiusRequest generates a "aws/request.Request" representing the
// client's request for the UpdateRadius operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 UpdateRadius for more information on using the UpdateRadius
// 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 UpdateRadiusRequest method.
//    req, resp := client.UpdateRadiusRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/UpdateRadius
func (c *DirectoryService) UpdateRadiusRequest(input *UpdateRadiusInput) (req *request.Request, output *UpdateRadiusOutput) {
	op := &request.Operation{
		Name:       opUpdateRadius,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateRadiusInput{}
	}

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

// UpdateRadius API operation for AWS Directory Service.
//
// Updates the Remote Authentication Dial In User Service (RADIUS) server information
// for an AD Connector directory.
//
// 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 AWS Directory Service's
// API operation UpdateRadius for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/UpdateRadius
func (c *DirectoryService) UpdateRadius(input *UpdateRadiusInput) (*UpdateRadiusOutput, error) {
	req, out := c.UpdateRadiusRequest(input)
	return out, req.Send()
}

// UpdateRadiusWithContext is the same as UpdateRadius with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateRadius 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 *DirectoryService) UpdateRadiusWithContext(ctx aws.Context, input *UpdateRadiusInput, opts ...request.Option) (*UpdateRadiusOutput, error) {
	req, out := c.UpdateRadiusRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opVerifyTrust = "VerifyTrust"

// VerifyTrustRequest generates a "aws/request.Request" representing the
// client's request for the VerifyTrust operation. The "output" return
// value will be populated with the request's response once the request completes
// 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 VerifyTrust for more information on using the VerifyTrust
// 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 VerifyTrustRequest method.
//    req, resp := client.VerifyTrustRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/VerifyTrust
func (c *DirectoryService) VerifyTrustRequest(input *VerifyTrustInput) (req *request.Request, output *VerifyTrustOutput) {
	op := &request.Operation{
		Name:       opVerifyTrust,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &VerifyTrustInput{}
	}

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

// VerifyTrust API operation for AWS Directory Service.
//
// AWS Directory Service for Microsoft Active Directory allows you to configure
// and verify trust relationships.
//
// This action verifies a trust relationship between your Microsoft AD in the
// AWS cloud and an external 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 AWS Directory Service's
// API operation VerifyTrust for usage and error information.
//
// Returned Error Codes:
//   * ErrCodeEntityDoesNotExistException "EntityDoesNotExistException"
//   The specified entity could not be found.
//
//   * ErrCodeInvalidParameterException "InvalidParameterException"
//   One or more parameters are not valid.
//
//   * ErrCodeClientException "ClientException"
//   A client exception has occurred.
//
//   * ErrCodeServiceException "ServiceException"
//   An exception has occurred in AWS Directory Service.
//
//   * ErrCodeUnsupportedOperationException "UnsupportedOperationException"
//   The operation is not supported.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/ds-2015-04-16/VerifyTrust
func (c *DirectoryService) VerifyTrust(input *VerifyTrustInput) (*VerifyTrustOutput, error) {
	req, out := c.VerifyTrustRequest(input)
	return out, req.Send()
}

// VerifyTrustWithContext is the same as VerifyTrust with the addition of
// the ability to pass a context and additional request options.
//
// See VerifyTrust 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 *DirectoryService) VerifyTrustWithContext(ctx aws.Context, input *VerifyTrustInput, opts ...request.Option) (*VerifyTrustOutput, error) {
	req, out := c.VerifyTrustRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

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

	// Identifier (ID) of the directory to which to add the address block.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// IP address blocks, using CIDR format, of the traffic to route. This is often
	// the IP address block of the DNS server used for your on-premises domain.
	//
	// IpRoutes is a required field
	IpRoutes []*IpRoute `type:"list" required:"true"`

	// If set to true, updates the inbound and outbound rules of the security group
	// that has the description: "AWS created security group for directory ID directory
	// controllers." Following are the new rules:
	//
	// Inbound:
	//
	//    * Type: Custom UDP Rule, Protocol: UDP, Range: 88, Source: 0.0.0.0/0
	//
	//    * Type: Custom UDP Rule, Protocol: UDP, Range: 123, Source: 0.0.0.0/0
	//
	//    * Type: Custom UDP Rule, Protocol: UDP, Range: 138, Source: 0.0.0.0/0
	//
	//    * Type: Custom UDP Rule, Protocol: UDP, Range: 389, Source: 0.0.0.0/0
	//
	//    * Type: Custom UDP Rule, Protocol: UDP, Range: 464, Source: 0.0.0.0/0
	//
	//    * Type: Custom UDP Rule, Protocol: UDP, Range: 445, Source: 0.0.0.0/0
	//
	//    * Type: Custom TCP Rule, Protocol: TCP, Range: 88, Source: 0.0.0.0/0
	//
	//    * Type: Custom TCP Rule, Protocol: TCP, Range: 135, Source: 0.0.0.0/0
	//
	//    * Type: Custom TCP Rule, Protocol: TCP, Range: 445, Source: 0.0.0.0/0
	//
	//    * Type: Custom TCP Rule, Protocol: TCP, Range: 464, Source: 0.0.0.0/0
	//
	//    * Type: Custom TCP Rule, Protocol: TCP, Range: 636, Source: 0.0.0.0/0
	//
	//    * Type: Custom TCP Rule, Protocol: TCP, Range: 1024-65535, Source: 0.0.0.0/0
	//
	//    * Type: Custom TCP Rule, Protocol: TCP, Range: 3268-33269, Source: 0.0.0.0/0
	//
	//    * Type: DNS (UDP), Protocol: UDP, Range: 53, Source: 0.0.0.0/0
	//
	//    * Type: DNS (TCP), Protocol: TCP, Range: 53, Source: 0.0.0.0/0
	//
	//    * Type: LDAP, Protocol: TCP, Range: 389, Source: 0.0.0.0/0
	//
	//    * Type: All ICMP, Protocol: All, Range: N/A, Source: 0.0.0.0/0
	//
	// Outbound:
	//
	// Type: All traffic, Protocol: All, Range: All, Destination: 0.0.0.0/0
	UpdateSecurityGroupForDirectoryControllers *bool `type:"boolean"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *AddIpRoutesInput) SetDirectoryId(v string) *AddIpRoutesInput {
	s.DirectoryId = &v
	return s
}

// SetIpRoutes sets the IpRoutes field's value.
func (s *AddIpRoutesInput) SetIpRoutes(v []*IpRoute) *AddIpRoutesInput {
	s.IpRoutes = v
	return s
}

// SetUpdateSecurityGroupForDirectoryControllers sets the UpdateSecurityGroupForDirectoryControllers field's value.
func (s *AddIpRoutesInput) SetUpdateSecurityGroupForDirectoryControllers(v bool) *AddIpRoutesInput {
	s.UpdateSecurityGroupForDirectoryControllers = &v
	return s
}

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

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

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

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

	// Identifier (ID) for the directory to which to add the tag.
	//
	// ResourceId is a required field
	ResourceId *string `type:"string" required:"true"`

	// The tags to be assigned to the directory.
	//
	// Tags is a required field
	Tags []*Tag `type:"list" required:"true"`
}

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

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

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

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

// SetResourceId sets the ResourceId field's value.
func (s *AddTagsToResourceInput) SetResourceId(v string) *AddTagsToResourceInput {
	s.ResourceId = &v
	return s
}

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

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

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

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

// Represents a named directory attribute.
type Attribute struct {
	_ struct{} `type:"structure"`

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

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

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

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

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

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

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

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

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

	// The identifier of the directory whose schema extension will be canceled.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The identifier of the schema extension that will be canceled.
	//
	// SchemaExtensionId is a required field
	SchemaExtensionId *string `type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *CancelSchemaExtensionInput) SetDirectoryId(v string) *CancelSchemaExtensionInput {
	s.DirectoryId = &v
	return s
}

// SetSchemaExtensionId sets the SchemaExtensionId field's value.
func (s *CancelSchemaExtensionInput) SetSchemaExtensionId(v string) *CancelSchemaExtensionInput {
	s.SchemaExtensionId = &v
	return s
}

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

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

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

// Contains information about a computer account in a directory.
type Computer struct {
	_ struct{} `type:"structure"`

	// An array of Attribute objects containing the LDAP attributes that belong
	// to the computer account.
	ComputerAttributes []*Attribute `type:"list"`

	// The identifier of the computer.
	ComputerId *string `min:"1" type:"string"`

	// The computer name.
	ComputerName *string `min:"1" type:"string"`
}

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

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

// SetComputerAttributes sets the ComputerAttributes field's value.
func (s *Computer) SetComputerAttributes(v []*Attribute) *Computer {
	s.ComputerAttributes = v
	return s
}

// SetComputerId sets the ComputerId field's value.
func (s *Computer) SetComputerId(v string) *Computer {
	s.ComputerId = &v
	return s
}

// SetComputerName sets the ComputerName field's value.
func (s *Computer) SetComputerName(v string) *Computer {
	s.ComputerName = &v
	return s
}

// Points to a remote domain with which you are setting up a trust relationship.
// Conditional forwarders are required in order to set up a trust relationship
// with another domain.
type ConditionalForwarder struct {
	_ struct{} `type:"structure"`

	// The IP addresses of the remote DNS server associated with RemoteDomainName.
	// This is the IP address of the DNS server that your conditional forwarder
	// points to.
	DnsIpAddrs []*string `type:"list"`

	// The fully qualified domain name (FQDN) of the remote domains pointed to by
	// the conditional forwarder.
	RemoteDomainName *string `type:"string"`

	// The replication scope of the conditional forwarder. The only allowed value
	// is Domain, which will replicate the conditional forwarder to all of the domain
	// controllers for your AWS directory.
	ReplicationScope *string `type:"string" enum:"ReplicationScope"`
}

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

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

// SetDnsIpAddrs sets the DnsIpAddrs field's value.
func (s *ConditionalForwarder) SetDnsIpAddrs(v []*string) *ConditionalForwarder {
	s.DnsIpAddrs = v
	return s
}

// SetRemoteDomainName sets the RemoteDomainName field's value.
func (s *ConditionalForwarder) SetRemoteDomainName(v string) *ConditionalForwarder {
	s.RemoteDomainName = &v
	return s
}

// SetReplicationScope sets the ReplicationScope field's value.
func (s *ConditionalForwarder) SetReplicationScope(v string) *ConditionalForwarder {
	s.ReplicationScope = &v
	return s
}

// Contains the inputs for the ConnectDirectory operation.
type ConnectDirectoryInput struct {
	_ struct{} `type:"structure"`

	// A DirectoryConnectSettings object that contains additional information for
	// the operation.
	//
	// ConnectSettings is a required field
	ConnectSettings *DirectoryConnectSettings `type:"structure" required:"true"`

	// A textual description for the directory.
	Description *string `type:"string"`

	// The fully-qualified name of the on-premises directory, such as corp.example.com.
	//
	// Name is a required field
	Name *string `type:"string" required:"true"`

	// The password for the on-premises user account.
	//
	// Password is a required field
	Password *string `min:"1" type:"string" required:"true"`

	// The NetBIOS name of the on-premises directory, such as CORP.
	ShortName *string `type:"string"`

	// The size of the directory.
	//
	// Size is a required field
	Size *string `type:"string" required:"true" enum:"DirectorySize"`
}

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

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

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

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

// SetConnectSettings sets the ConnectSettings field's value.
func (s *ConnectDirectoryInput) SetConnectSettings(v *DirectoryConnectSettings) *ConnectDirectoryInput {
	s.ConnectSettings = v
	return s
}

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

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

// SetPassword sets the Password field's value.
func (s *ConnectDirectoryInput) SetPassword(v string) *ConnectDirectoryInput {
	s.Password = &v
	return s
}

// SetShortName sets the ShortName field's value.
func (s *ConnectDirectoryInput) SetShortName(v string) *ConnectDirectoryInput {
	s.ShortName = &v
	return s
}

// SetSize sets the Size field's value.
func (s *ConnectDirectoryInput) SetSize(v string) *ConnectDirectoryInput {
	s.Size = &v
	return s
}

// Contains the results of the ConnectDirectory operation.
type ConnectDirectoryOutput struct {
	_ struct{} `type:"structure"`

	// The identifier of the new directory.
	DirectoryId *string `type:"string"`
}

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *ConnectDirectoryOutput) SetDirectoryId(v string) *ConnectDirectoryOutput {
	s.DirectoryId = &v
	return s
}

// Contains the inputs for the CreateAlias operation.
type CreateAliasInput struct {
	_ struct{} `type:"structure"`

	// The requested alias.
	//
	// The alias must be unique amongst all aliases in AWS. This operation throws
	// an EntityAlreadyExistsException error if the alias already exists.
	//
	// Alias is a required field
	Alias *string `min:"1" type:"string" required:"true"`

	// The identifier of the directory for which to create the alias.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`
}

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

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

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

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

// SetAlias sets the Alias field's value.
func (s *CreateAliasInput) SetAlias(v string) *CreateAliasInput {
	s.Alias = &v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *CreateAliasInput) SetDirectoryId(v string) *CreateAliasInput {
	s.DirectoryId = &v
	return s
}

// Contains the results of the CreateAlias operation.
type CreateAliasOutput struct {
	_ struct{} `type:"structure"`

	// The alias for the directory.
	Alias *string `min:"1" type:"string"`

	// The identifier of the directory.
	DirectoryId *string `type:"string"`
}

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

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

// SetAlias sets the Alias field's value.
func (s *CreateAliasOutput) SetAlias(v string) *CreateAliasOutput {
	s.Alias = &v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *CreateAliasOutput) SetDirectoryId(v string) *CreateAliasOutput {
	s.DirectoryId = &v
	return s
}

// Contains the inputs for the CreateComputer operation.
type CreateComputerInput struct {
	_ struct{} `type:"structure"`

	// An array of Attribute objects that contain any LDAP attributes to apply to
	// the computer account.
	ComputerAttributes []*Attribute `type:"list"`

	// The name of the computer account.
	//
	// ComputerName is a required field
	ComputerName *string `min:"1" type:"string" required:"true"`

	// The identifier of the directory in which to create the computer account.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The fully-qualified distinguished name of the organizational unit to place
	// the computer account in.
	OrganizationalUnitDistinguishedName *string `min:"1" type:"string"`

	// A one-time password that is used to join the computer to the directory. You
	// should generate a random, strong password to use for this parameter.
	//
	// Password is a required field
	Password *string `min:"8" type:"string" required:"true"`
}

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

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

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

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

// SetComputerAttributes sets the ComputerAttributes field's value.
func (s *CreateComputerInput) SetComputerAttributes(v []*Attribute) *CreateComputerInput {
	s.ComputerAttributes = v
	return s
}

// SetComputerName sets the ComputerName field's value.
func (s *CreateComputerInput) SetComputerName(v string) *CreateComputerInput {
	s.ComputerName = &v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *CreateComputerInput) SetDirectoryId(v string) *CreateComputerInput {
	s.DirectoryId = &v
	return s
}

// SetOrganizationalUnitDistinguishedName sets the OrganizationalUnitDistinguishedName field's value.
func (s *CreateComputerInput) SetOrganizationalUnitDistinguishedName(v string) *CreateComputerInput {
	s.OrganizationalUnitDistinguishedName = &v
	return s
}

// SetPassword sets the Password field's value.
func (s *CreateComputerInput) SetPassword(v string) *CreateComputerInput {
	s.Password = &v
	return s
}

// Contains the results for the CreateComputer operation.
type CreateComputerOutput struct {
	_ struct{} `type:"structure"`

	// A Computer object that represents the computer account.
	Computer *Computer `type:"structure"`
}

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

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

// SetComputer sets the Computer field's value.
func (s *CreateComputerOutput) SetComputer(v *Computer) *CreateComputerOutput {
	s.Computer = v
	return s
}

// Initiates the creation of a conditional forwarder for your AWS Directory
// Service for Microsoft Active Directory. Conditional forwarders are required
// in order to set up a trust relationship with another domain.
type CreateConditionalForwarderInput struct {
	_ struct{} `type:"structure"`

	// The directory ID of the AWS directory for which you are creating the conditional
	// forwarder.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The IP addresses of the remote DNS server associated with RemoteDomainName.
	//
	// DnsIpAddrs is a required field
	DnsIpAddrs []*string `type:"list" required:"true"`

	// The fully qualified domain name (FQDN) of the remote domain with which you
	// will set up a trust relationship.
	//
	// RemoteDomainName is a required field
	RemoteDomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *CreateConditionalForwarderInput) SetDirectoryId(v string) *CreateConditionalForwarderInput {
	s.DirectoryId = &v
	return s
}

// SetDnsIpAddrs sets the DnsIpAddrs field's value.
func (s *CreateConditionalForwarderInput) SetDnsIpAddrs(v []*string) *CreateConditionalForwarderInput {
	s.DnsIpAddrs = v
	return s
}

// SetRemoteDomainName sets the RemoteDomainName field's value.
func (s *CreateConditionalForwarderInput) SetRemoteDomainName(v string) *CreateConditionalForwarderInput {
	s.RemoteDomainName = &v
	return s
}

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

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

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

// Contains the inputs for the CreateDirectory operation.
type CreateDirectoryInput struct {
	_ struct{} `type:"structure"`

	// A textual description for the directory.
	Description *string `type:"string"`

	// The fully qualified name for the directory, such as corp.example.com.
	//
	// Name is a required field
	Name *string `type:"string" required:"true"`

	// The password for the directory administrator. The directory creation process
	// creates a directory administrator account with the username Administrator
	// and this password.
	//
	// Password is a required field
	Password *string `type:"string" required:"true"`

	// The short name of the directory, such as CORP.
	ShortName *string `type:"string"`

	// The size of the directory.
	//
	// Size is a required field
	Size *string `type:"string" required:"true" enum:"DirectorySize"`

	// A DirectoryVpcSettings object that contains additional information for the
	// operation.
	VpcSettings *DirectoryVpcSettings `type:"structure"`
}

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

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

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

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

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

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

// SetPassword sets the Password field's value.
func (s *CreateDirectoryInput) SetPassword(v string) *CreateDirectoryInput {
	s.Password = &v
	return s
}

// SetShortName sets the ShortName field's value.
func (s *CreateDirectoryInput) SetShortName(v string) *CreateDirectoryInput {
	s.ShortName = &v
	return s
}

// SetSize sets the Size field's value.
func (s *CreateDirectoryInput) SetSize(v string) *CreateDirectoryInput {
	s.Size = &v
	return s
}

// SetVpcSettings sets the VpcSettings field's value.
func (s *CreateDirectoryInput) SetVpcSettings(v *DirectoryVpcSettings) *CreateDirectoryInput {
	s.VpcSettings = v
	return s
}

// Contains the results of the CreateDirectory operation.
type CreateDirectoryOutput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory that was created.
	DirectoryId *string `type:"string"`
}

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *CreateDirectoryOutput) SetDirectoryId(v string) *CreateDirectoryOutput {
	s.DirectoryId = &v
	return s
}

// Creates a Microsoft AD in the AWS cloud.
type CreateMicrosoftADInput struct {
	_ struct{} `type:"structure"`

	// A textual description for the directory. This label will appear on the AWS
	// console Directory Details page after the directory is created.
	Description *string `type:"string"`

	// AWS Microsoft AD is available in two editions: Standard and Enterprise. Enterprise
	// is the default.
	Edition *string `type:"string" enum:"DirectoryEdition"`

	// The fully qualified domain name for the directory, such as corp.example.com.
	// This name will resolve inside your VPC only. It does not need to be publicly
	// resolvable.
	//
	// Name is a required field
	Name *string `type:"string" required:"true"`

	// The password for the default administrative user named Admin.
	//
	// Password is a required field
	Password *string `type:"string" required:"true"`

	// The NetBIOS name for your domain. A short identifier for your domain, such
	// as CORP. If you don't specify a NetBIOS name, it will default to the first
	// part of your directory DNS. For example, CORP for the directory DNS corp.example.com.
	ShortName *string `type:"string"`

	// Contains VPC information for the CreateDirectory or CreateMicrosoftAD operation.
	//
	// VpcSettings is a required field
	VpcSettings *DirectoryVpcSettings `type:"structure" required:"true"`
}

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

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

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

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

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

// SetEdition sets the Edition field's value.
func (s *CreateMicrosoftADInput) SetEdition(v string) *CreateMicrosoftADInput {
	s.Edition = &v
	return s
}

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

// SetPassword sets the Password field's value.
func (s *CreateMicrosoftADInput) SetPassword(v string) *CreateMicrosoftADInput {
	s.Password = &v
	return s
}

// SetShortName sets the ShortName field's value.
func (s *CreateMicrosoftADInput) SetShortName(v string) *CreateMicrosoftADInput {
	s.ShortName = &v
	return s
}

// SetVpcSettings sets the VpcSettings field's value.
func (s *CreateMicrosoftADInput) SetVpcSettings(v *DirectoryVpcSettings) *CreateMicrosoftADInput {
	s.VpcSettings = v
	return s
}

// Result of a CreateMicrosoftAD request.
type CreateMicrosoftADOutput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory that was created.
	DirectoryId *string `type:"string"`
}

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *CreateMicrosoftADOutput) SetDirectoryId(v string) *CreateMicrosoftADOutput {
	s.DirectoryId = &v
	return s
}

// Contains the inputs for the CreateSnapshot operation.
type CreateSnapshotInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory of which to take a snapshot.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The descriptive name to apply to the snapshot.
	Name *string `type:"string"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *CreateSnapshotInput) SetDirectoryId(v string) *CreateSnapshotInput {
	s.DirectoryId = &v
	return s
}

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

// Contains the results of the CreateSnapshot operation.
type CreateSnapshotOutput struct {
	_ struct{} `type:"structure"`

	// The identifier of the snapshot that was created.
	SnapshotId *string `type:"string"`
}

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

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

// SetSnapshotId sets the SnapshotId field's value.
func (s *CreateSnapshotOutput) SetSnapshotId(v string) *CreateSnapshotOutput {
	s.SnapshotId = &v
	return s
}

// AWS Directory Service for Microsoft Active Directory allows you to configure
// trust relationships. For example, you can establish a trust between your
// Microsoft AD in the AWS cloud, and your existing on-premises Microsoft Active
// Directory. This would allow you to provide users and groups access to resources
// in either domain, with a single set of credentials.
//
// This action initiates the creation of the AWS side of a trust relationship
// between a Microsoft AD in the AWS cloud and an external domain.
type CreateTrustInput struct {
	_ struct{} `type:"structure"`

	// The IP addresses of the remote DNS server associated with RemoteDomainName.
	ConditionalForwarderIpAddrs []*string `type:"list"`

	// The Directory ID of the Microsoft AD in the AWS cloud for which to establish
	// the trust relationship.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The Fully Qualified Domain Name (FQDN) of the external domain for which to
	// create the trust relationship.
	//
	// RemoteDomainName is a required field
	RemoteDomainName *string `type:"string" required:"true"`

	// The direction of the trust relationship.
	//
	// TrustDirection is a required field
	TrustDirection *string `type:"string" required:"true" enum:"TrustDirection"`

	// The trust password. The must be the same password that was used when creating
	// the trust relationship on the external domain.
	//
	// TrustPassword is a required field
	TrustPassword *string `min:"1" type:"string" required:"true"`

	// The trust relationship type.
	TrustType *string `type:"string" enum:"TrustType"`
}

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

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

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

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

// SetConditionalForwarderIpAddrs sets the ConditionalForwarderIpAddrs field's value.
func (s *CreateTrustInput) SetConditionalForwarderIpAddrs(v []*string) *CreateTrustInput {
	s.ConditionalForwarderIpAddrs = v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *CreateTrustInput) SetDirectoryId(v string) *CreateTrustInput {
	s.DirectoryId = &v
	return s
}

// SetRemoteDomainName sets the RemoteDomainName field's value.
func (s *CreateTrustInput) SetRemoteDomainName(v string) *CreateTrustInput {
	s.RemoteDomainName = &v
	return s
}

// SetTrustDirection sets the TrustDirection field's value.
func (s *CreateTrustInput) SetTrustDirection(v string) *CreateTrustInput {
	s.TrustDirection = &v
	return s
}

// SetTrustPassword sets the TrustPassword field's value.
func (s *CreateTrustInput) SetTrustPassword(v string) *CreateTrustInput {
	s.TrustPassword = &v
	return s
}

// SetTrustType sets the TrustType field's value.
func (s *CreateTrustInput) SetTrustType(v string) *CreateTrustInput {
	s.TrustType = &v
	return s
}

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

	// A unique identifier for the trust relationship that was created.
	TrustId *string `type:"string"`
}

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

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

// SetTrustId sets the TrustId field's value.
func (s *CreateTrustOutput) SetTrustId(v string) *CreateTrustOutput {
	s.TrustId = &v
	return s
}

// Deletes a conditional forwarder.
type DeleteConditionalForwarderInput struct {
	_ struct{} `type:"structure"`

	// The directory ID for which you are deleting the conditional forwarder.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The fully qualified domain name (FQDN) of the remote domain with which you
	// are deleting the conditional forwarder.
	//
	// RemoteDomainName is a required field
	RemoteDomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DeleteConditionalForwarderInput) SetDirectoryId(v string) *DeleteConditionalForwarderInput {
	s.DirectoryId = &v
	return s
}

// SetRemoteDomainName sets the RemoteDomainName field's value.
func (s *DeleteConditionalForwarderInput) SetRemoteDomainName(v string) *DeleteConditionalForwarderInput {
	s.RemoteDomainName = &v
	return s
}

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

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

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

// Contains the inputs for the DeleteDirectory operation.
type DeleteDirectoryInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory to delete.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DeleteDirectoryInput) SetDirectoryId(v string) *DeleteDirectoryInput {
	s.DirectoryId = &v
	return s
}

// Contains the results of the DeleteDirectory operation.
type DeleteDirectoryOutput struct {
	_ struct{} `type:"structure"`

	// The directory identifier.
	DirectoryId *string `type:"string"`
}

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DeleteDirectoryOutput) SetDirectoryId(v string) *DeleteDirectoryOutput {
	s.DirectoryId = &v
	return s
}

// Contains the inputs for the DeleteSnapshot operation.
type DeleteSnapshotInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory snapshot to be deleted.
	//
	// SnapshotId is a required field
	SnapshotId *string `type:"string" required:"true"`
}

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

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

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

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

// SetSnapshotId sets the SnapshotId field's value.
func (s *DeleteSnapshotInput) SetSnapshotId(v string) *DeleteSnapshotInput {
	s.SnapshotId = &v
	return s
}

// Contains the results of the DeleteSnapshot operation.
type DeleteSnapshotOutput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory snapshot that was deleted.
	SnapshotId *string `type:"string"`
}

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

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

// SetSnapshotId sets the SnapshotId field's value.
func (s *DeleteSnapshotOutput) SetSnapshotId(v string) *DeleteSnapshotOutput {
	s.SnapshotId = &v
	return s
}

// Deletes the local side of an existing trust relationship between the Microsoft
// AD in the AWS cloud and the external domain.
type DeleteTrustInput struct {
	_ struct{} `type:"structure"`

	// Delete a conditional forwarder as part of a DeleteTrustRequest.
	DeleteAssociatedConditionalForwarder *bool `type:"boolean"`

	// The Trust ID of the trust relationship to be deleted.
	//
	// TrustId is a required field
	TrustId *string `type:"string" required:"true"`
}

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

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

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

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

// SetDeleteAssociatedConditionalForwarder sets the DeleteAssociatedConditionalForwarder field's value.
func (s *DeleteTrustInput) SetDeleteAssociatedConditionalForwarder(v bool) *DeleteTrustInput {
	s.DeleteAssociatedConditionalForwarder = &v
	return s
}

// SetTrustId sets the TrustId field's value.
func (s *DeleteTrustInput) SetTrustId(v string) *DeleteTrustInput {
	s.TrustId = &v
	return s
}

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

	// The Trust ID of the trust relationship that was deleted.
	TrustId *string `type:"string"`
}

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

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

// SetTrustId sets the TrustId field's value.
func (s *DeleteTrustOutput) SetTrustId(v string) *DeleteTrustOutput {
	s.TrustId = &v
	return s
}

// Removes the specified directory as a publisher to the specified SNS topic.
type DeregisterEventTopicInput struct {
	_ struct{} `type:"structure"`

	// The Directory ID to remove as a publisher. This directory will no longer
	// send messages to the specified SNS topic.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The name of the SNS topic from which to remove the directory as a publisher.
	//
	// TopicName is a required field
	TopicName *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DeregisterEventTopicInput) SetDirectoryId(v string) *DeregisterEventTopicInput {
	s.DirectoryId = &v
	return s
}

// SetTopicName sets the TopicName field's value.
func (s *DeregisterEventTopicInput) SetTopicName(v string) *DeregisterEventTopicInput {
	s.TopicName = &v
	return s
}

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

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

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

// Describes a conditional forwarder.
type DescribeConditionalForwardersInput struct {
	_ struct{} `type:"structure"`

	// The directory ID for which to get the list of associated conditional forwarders.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The fully qualified domain names (FQDN) of the remote domains for which to
	// get the list of associated conditional forwarders. If this member is null,
	// all conditional forwarders are returned.
	RemoteDomainNames []*string `type:"list"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DescribeConditionalForwardersInput) SetDirectoryId(v string) *DescribeConditionalForwardersInput {
	s.DirectoryId = &v
	return s
}

// SetRemoteDomainNames sets the RemoteDomainNames field's value.
func (s *DescribeConditionalForwardersInput) SetRemoteDomainNames(v []*string) *DescribeConditionalForwardersInput {
	s.RemoteDomainNames = v
	return s
}

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

	// The list of conditional forwarders that have been created.
	ConditionalForwarders []*ConditionalForwarder `type:"list"`
}

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

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

// SetConditionalForwarders sets the ConditionalForwarders field's value.
func (s *DescribeConditionalForwardersOutput) SetConditionalForwarders(v []*ConditionalForwarder) *DescribeConditionalForwardersOutput {
	s.ConditionalForwarders = v
	return s
}

// Contains the inputs for the DescribeDirectories operation.
type DescribeDirectoriesInput struct {
	_ struct{} `type:"structure"`

	// A list of identifiers of the directories for which to obtain the information.
	// If this member is null, all directories that belong to the current account
	// are returned.
	//
	// An empty list results in an InvalidParameterException being thrown.
	DirectoryIds []*string `type:"list"`

	// The maximum number of items to return. If this value is zero, the maximum
	// number of items is specified by the limitations of the operation.
	Limit *int64 `type:"integer"`

	// The DescribeDirectoriesResult.NextToken value from a previous call to DescribeDirectories.
	// Pass null if this is the first call.
	NextToken *string `type:"string"`
}

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

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

// SetDirectoryIds sets the DirectoryIds field's value.
func (s *DescribeDirectoriesInput) SetDirectoryIds(v []*string) *DescribeDirectoriesInput {
	s.DirectoryIds = v
	return s
}

// SetLimit sets the Limit field's value.
func (s *DescribeDirectoriesInput) SetLimit(v int64) *DescribeDirectoriesInput {
	s.Limit = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *DescribeDirectoriesInput) SetNextToken(v string) *DescribeDirectoriesInput {
	s.NextToken = &v
	return s
}

// Contains the results of the DescribeDirectories operation.
type DescribeDirectoriesOutput struct {
	_ struct{} `type:"structure"`

	// The list of DirectoryDescription objects that were retrieved.
	//
	// It is possible that this list contains less than the number of items specified
	// in the Limit member of the request. This occurs if there are less than the
	// requested number of items left to retrieve, or if the limitations of the
	// operation have been exceeded.
	DirectoryDescriptions []*DirectoryDescription `type:"list"`

	// If not null, more results are available. Pass this value for the NextToken
	// parameter in a subsequent call to DescribeDirectories to retrieve the next
	// set of items.
	NextToken *string `type:"string"`
}

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

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

// SetDirectoryDescriptions sets the DirectoryDescriptions field's value.
func (s *DescribeDirectoriesOutput) SetDirectoryDescriptions(v []*DirectoryDescription) *DescribeDirectoriesOutput {
	s.DirectoryDescriptions = v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *DescribeDirectoriesOutput) SetNextToken(v string) *DescribeDirectoriesOutput {
	s.NextToken = &v
	return s
}

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

	// Identifier of the directory for which to retrieve the domain controller information.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// A list of identifiers for the domain controllers whose information will be
	// provided.
	DomainControllerIds []*string `type:"list"`

	// The maximum number of items to return.
	Limit *int64 `type:"integer"`

	// The DescribeDomainControllers.NextToken value from a previous call to DescribeDomainControllers.
	// Pass null if this is the first call.
	NextToken *string `type:"string"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DescribeDomainControllersInput) SetDirectoryId(v string) *DescribeDomainControllersInput {
	s.DirectoryId = &v
	return s
}

// SetDomainControllerIds sets the DomainControllerIds field's value.
func (s *DescribeDomainControllersInput) SetDomainControllerIds(v []*string) *DescribeDomainControllersInput {
	s.DomainControllerIds = v
	return s
}

// SetLimit sets the Limit field's value.
func (s *DescribeDomainControllersInput) SetLimit(v int64) *DescribeDomainControllersInput {
	s.Limit = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *DescribeDomainControllersInput) SetNextToken(v string) *DescribeDomainControllersInput {
	s.NextToken = &v
	return s
}

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

	// List of the DomainController objects that were retrieved.
	DomainControllers []*DomainController `type:"list"`

	// If not null, more results are available. Pass this value for the NextToken
	// parameter in a subsequent call to DescribeDomainControllers retrieve the
	// next set of items.
	NextToken *string `type:"string"`
}

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

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

// SetDomainControllers sets the DomainControllers field's value.
func (s *DescribeDomainControllersOutput) SetDomainControllers(v []*DomainController) *DescribeDomainControllersOutput {
	s.DomainControllers = v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *DescribeDomainControllersOutput) SetNextToken(v string) *DescribeDomainControllersOutput {
	s.NextToken = &v
	return s
}

// Describes event topics.
type DescribeEventTopicsInput struct {
	_ struct{} `type:"structure"`

	// The Directory ID for which to get the list of associated SNS topics. If this
	// member is null, associations for all Directory IDs are returned.
	DirectoryId *string `type:"string"`

	// A list of SNS topic names for which to obtain the information. If this member
	// is null, all associations for the specified Directory ID are returned.
	//
	// An empty list results in an InvalidParameterException being thrown.
	TopicNames []*string `type:"list"`
}

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DescribeEventTopicsInput) SetDirectoryId(v string) *DescribeEventTopicsInput {
	s.DirectoryId = &v
	return s
}

// SetTopicNames sets the TopicNames field's value.
func (s *DescribeEventTopicsInput) SetTopicNames(v []*string) *DescribeEventTopicsInput {
	s.TopicNames = v
	return s
}

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

	// A list of SNS topic names that receive status messages from the specified
	// Directory ID.
	EventTopics []*EventTopic `type:"list"`
}

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

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

// SetEventTopics sets the EventTopics field's value.
func (s *DescribeEventTopicsOutput) SetEventTopics(v []*EventTopic) *DescribeEventTopicsOutput {
	s.EventTopics = v
	return s
}

// Contains the inputs for the DescribeSnapshots operation.
type DescribeSnapshotsInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory for which to retrieve snapshot information.
	DirectoryId *string `type:"string"`

	// The maximum number of objects to return.
	Limit *int64 `type:"integer"`

	// The DescribeSnapshotsResult.NextToken value from a previous call to DescribeSnapshots.
	// Pass null if this is the first call.
	NextToken *string `type:"string"`

	// A list of identifiers of the snapshots to obtain the information for. If
	// this member is null or empty, all snapshots are returned using the Limit
	// and NextToken members.
	SnapshotIds []*string `type:"list"`
}

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DescribeSnapshotsInput) SetDirectoryId(v string) *DescribeSnapshotsInput {
	s.DirectoryId = &v
	return s
}

// SetLimit sets the Limit field's value.
func (s *DescribeSnapshotsInput) SetLimit(v int64) *DescribeSnapshotsInput {
	s.Limit = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *DescribeSnapshotsInput) SetNextToken(v string) *DescribeSnapshotsInput {
	s.NextToken = &v
	return s
}

// SetSnapshotIds sets the SnapshotIds field's value.
func (s *DescribeSnapshotsInput) SetSnapshotIds(v []*string) *DescribeSnapshotsInput {
	s.SnapshotIds = v
	return s
}

// Contains the results of the DescribeSnapshots operation.
type DescribeSnapshotsOutput struct {
	_ struct{} `type:"structure"`

	// If not null, more results are available. Pass this value in the NextToken
	// member of a subsequent call to DescribeSnapshots.
	NextToken *string `type:"string"`

	// The list of Snapshot objects that were retrieved.
	//
	// It is possible that this list contains less than the number of items specified
	// in the Limit member of the request. This occurs if there are less than the
	// requested number of items left to retrieve, or if the limitations of the
	// operation have been exceeded.
	Snapshots []*Snapshot `type:"list"`
}

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

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

// SetNextToken sets the NextToken field's value.
func (s *DescribeSnapshotsOutput) SetNextToken(v string) *DescribeSnapshotsOutput {
	s.NextToken = &v
	return s
}

// SetSnapshots sets the Snapshots field's value.
func (s *DescribeSnapshotsOutput) SetSnapshots(v []*Snapshot) *DescribeSnapshotsOutput {
	s.Snapshots = v
	return s
}

// Describes the trust relationships for a particular Microsoft AD in the AWS
// cloud. If no input parameters are are provided, such as directory ID or trust
// ID, this request describes all the trust relationships.
type DescribeTrustsInput struct {
	_ struct{} `type:"structure"`

	// The Directory ID of the AWS directory that is a part of the requested trust
	// relationship.
	DirectoryId *string `type:"string"`

	// The maximum number of objects to return.
	Limit *int64 `type:"integer"`

	// The DescribeTrustsResult.NextToken value from a previous call to DescribeTrusts.
	// Pass null if this is the first call.
	NextToken *string `type:"string"`

	// A list of identifiers of the trust relationships for which to obtain the
	// information. If this member is null, all trust relationships that belong
	// to the current account are returned.
	//
	// An empty list results in an InvalidParameterException being thrown.
	TrustIds []*string `type:"list"`
}

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DescribeTrustsInput) SetDirectoryId(v string) *DescribeTrustsInput {
	s.DirectoryId = &v
	return s
}

// SetLimit sets the Limit field's value.
func (s *DescribeTrustsInput) SetLimit(v int64) *DescribeTrustsInput {
	s.Limit = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *DescribeTrustsInput) SetNextToken(v string) *DescribeTrustsInput {
	s.NextToken = &v
	return s
}

// SetTrustIds sets the TrustIds field's value.
func (s *DescribeTrustsInput) SetTrustIds(v []*string) *DescribeTrustsInput {
	s.TrustIds = v
	return s
}

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

	// If not null, more results are available. Pass this value for the NextToken
	// parameter in a subsequent call to DescribeTrusts to retrieve the next set
	// of items.
	NextToken *string `type:"string"`

	// The list of Trust objects that were retrieved.
	//
	// It is possible that this list contains less than the number of items specified
	// in the Limit member of the request. This occurs if there are less than the
	// requested number of items left to retrieve, or if the limitations of the
	// operation have been exceeded.
	Trusts []*Trust `type:"list"`
}

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

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

// SetNextToken sets the NextToken field's value.
func (s *DescribeTrustsOutput) SetNextToken(v string) *DescribeTrustsOutput {
	s.NextToken = &v
	return s
}

// SetTrusts sets the Trusts field's value.
func (s *DescribeTrustsOutput) SetTrusts(v []*Trust) *DescribeTrustsOutput {
	s.Trusts = v
	return s
}

// Contains information for the ConnectDirectory operation when an AD Connector
// directory is being created.
type DirectoryConnectSettings struct {
	_ struct{} `type:"structure"`

	// A list of one or more IP addresses of DNS servers or domain controllers in
	// the on-premises directory.
	//
	// CustomerDnsIps is a required field
	CustomerDnsIps []*string `type:"list" required:"true"`

	// The username of an account in the on-premises directory that is used to connect
	// to the directory. This account must have the following privileges:
	//
	//    * Read users and groups
	//
	//    * Create computer objects
	//
	//    * Join computers to the domain
	//
	// CustomerUserName is a required field
	CustomerUserName *string `min:"1" type:"string" required:"true"`

	// A list of subnet identifiers in the VPC in which the AD Connector is created.
	//
	// SubnetIds is a required field
	SubnetIds []*string `type:"list" required:"true"`

	// The identifier of the VPC in which the AD Connector is created.
	//
	// VpcId is a required field
	VpcId *string `type:"string" required:"true"`
}

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

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

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

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

// SetCustomerDnsIps sets the CustomerDnsIps field's value.
func (s *DirectoryConnectSettings) SetCustomerDnsIps(v []*string) *DirectoryConnectSettings {
	s.CustomerDnsIps = v
	return s
}

// SetCustomerUserName sets the CustomerUserName field's value.
func (s *DirectoryConnectSettings) SetCustomerUserName(v string) *DirectoryConnectSettings {
	s.CustomerUserName = &v
	return s
}

// SetSubnetIds sets the SubnetIds field's value.
func (s *DirectoryConnectSettings) SetSubnetIds(v []*string) *DirectoryConnectSettings {
	s.SubnetIds = v
	return s
}

// SetVpcId sets the VpcId field's value.
func (s *DirectoryConnectSettings) SetVpcId(v string) *DirectoryConnectSettings {
	s.VpcId = &v
	return s
}

// Contains information about an AD Connector directory.
type DirectoryConnectSettingsDescription struct {
	_ struct{} `type:"structure"`

	// A list of the Availability Zones that the directory is in.
	AvailabilityZones []*string `type:"list"`

	// The IP addresses of the AD Connector servers.
	ConnectIps []*string `type:"list"`

	// The username of the service account in the on-premises directory.
	CustomerUserName *string `min:"1" type:"string"`

	// The security group identifier for the AD Connector directory.
	SecurityGroupId *string `type:"string"`

	// A list of subnet identifiers in the VPC that the AD connector is in.
	SubnetIds []*string `type:"list"`

	// The identifier of the VPC that the AD Connector is in.
	VpcId *string `type:"string"`
}

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

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

// SetAvailabilityZones sets the AvailabilityZones field's value.
func (s *DirectoryConnectSettingsDescription) SetAvailabilityZones(v []*string) *DirectoryConnectSettingsDescription {
	s.AvailabilityZones = v
	return s
}

// SetConnectIps sets the ConnectIps field's value.
func (s *DirectoryConnectSettingsDescription) SetConnectIps(v []*string) *DirectoryConnectSettingsDescription {
	s.ConnectIps = v
	return s
}

// SetCustomerUserName sets the CustomerUserName field's value.
func (s *DirectoryConnectSettingsDescription) SetCustomerUserName(v string) *DirectoryConnectSettingsDescription {
	s.CustomerUserName = &v
	return s
}

// SetSecurityGroupId sets the SecurityGroupId field's value.
func (s *DirectoryConnectSettingsDescription) SetSecurityGroupId(v string) *DirectoryConnectSettingsDescription {
	s.SecurityGroupId = &v
	return s
}

// SetSubnetIds sets the SubnetIds field's value.
func (s *DirectoryConnectSettingsDescription) SetSubnetIds(v []*string) *DirectoryConnectSettingsDescription {
	s.SubnetIds = v
	return s
}

// SetVpcId sets the VpcId field's value.
func (s *DirectoryConnectSettingsDescription) SetVpcId(v string) *DirectoryConnectSettingsDescription {
	s.VpcId = &v
	return s
}

// Contains information about an AWS Directory Service directory.
type DirectoryDescription struct {
	_ struct{} `type:"structure"`

	// The access URL for the directory, such as http://<alias>.awsapps.com. If
	// no alias has been created for the directory, <alias> is the directory identifier,
	// such as d-XXXXXXXXXX.
	AccessUrl *string `min:"1" type:"string"`

	// The alias for the directory. If no alias has been created for the directory,
	// the alias is the directory identifier, such as d-XXXXXXXXXX.
	Alias *string `min:"1" type:"string"`

	// A DirectoryConnectSettingsDescription object that contains additional information
	// about an AD Connector directory. This member is only present if the directory
	// is an AD Connector directory.
	ConnectSettings *DirectoryConnectSettingsDescription `type:"structure"`

	// The textual description for the directory.
	Description *string `type:"string"`

	// The desired number of domain controllers in the directory if the directory
	// is Microsoft AD.
	DesiredNumberOfDomainControllers *int64 `min:"2" type:"integer"`

	// The directory identifier.
	DirectoryId *string `type:"string"`

	// The IP addresses of the DNS servers for the directory. For a Simple AD or
	// Microsoft AD directory, these are the IP addresses of the Simple AD or Microsoft
	// AD directory servers. For an AD Connector directory, these are the IP addresses
	// of the DNS servers or domain controllers in the on-premises directory to
	// which the AD Connector is connected.
	DnsIpAddrs []*string `type:"list"`

	// The edition associated with this directory.
	Edition *string `type:"string" enum:"DirectoryEdition"`

	// Specifies when the directory was created.
	LaunchTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The fully-qualified name of the directory.
	Name *string `type:"string"`

	// A RadiusSettings object that contains information about the RADIUS server
	// configured for this directory.
	RadiusSettings *RadiusSettings `type:"structure"`

	// The status of the RADIUS MFA server connection.
	RadiusStatus *string `type:"string" enum:"RadiusStatus"`

	// The short name of the directory.
	ShortName *string `type:"string"`

	// The directory size.
	Size *string `type:"string" enum:"DirectorySize"`

	// Indicates if single-sign on is enabled for the directory. For more information,
	// see EnableSso and DisableSso.
	SsoEnabled *bool `type:"boolean"`

	// The current stage of the directory.
	Stage *string `type:"string" enum:"DirectoryStage"`

	// The date and time that the stage was last updated.
	StageLastUpdatedDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// Additional information about the directory stage.
	StageReason *string `type:"string"`

	// The directory size.
	Type *string `type:"string" enum:"DirectoryType"`

	// A DirectoryVpcSettingsDescription object that contains additional information
	// about a directory. This member is only present if the directory is a Simple
	// AD or Managed AD directory.
	VpcSettings *DirectoryVpcSettingsDescription `type:"structure"`
}

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

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

// SetAccessUrl sets the AccessUrl field's value.
func (s *DirectoryDescription) SetAccessUrl(v string) *DirectoryDescription {
	s.AccessUrl = &v
	return s
}

// SetAlias sets the Alias field's value.
func (s *DirectoryDescription) SetAlias(v string) *DirectoryDescription {
	s.Alias = &v
	return s
}

// SetConnectSettings sets the ConnectSettings field's value.
func (s *DirectoryDescription) SetConnectSettings(v *DirectoryConnectSettingsDescription) *DirectoryDescription {
	s.ConnectSettings = v
	return s
}

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

// SetDesiredNumberOfDomainControllers sets the DesiredNumberOfDomainControllers field's value.
func (s *DirectoryDescription) SetDesiredNumberOfDomainControllers(v int64) *DirectoryDescription {
	s.DesiredNumberOfDomainControllers = &v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *DirectoryDescription) SetDirectoryId(v string) *DirectoryDescription {
	s.DirectoryId = &v
	return s
}

// SetDnsIpAddrs sets the DnsIpAddrs field's value.
func (s *DirectoryDescription) SetDnsIpAddrs(v []*string) *DirectoryDescription {
	s.DnsIpAddrs = v
	return s
}

// SetEdition sets the Edition field's value.
func (s *DirectoryDescription) SetEdition(v string) *DirectoryDescription {
	s.Edition = &v
	return s
}

// SetLaunchTime sets the LaunchTime field's value.
func (s *DirectoryDescription) SetLaunchTime(v time.Time) *DirectoryDescription {
	s.LaunchTime = &v
	return s
}

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

// SetRadiusSettings sets the RadiusSettings field's value.
func (s *DirectoryDescription) SetRadiusSettings(v *RadiusSettings) *DirectoryDescription {
	s.RadiusSettings = v
	return s
}

// SetRadiusStatus sets the RadiusStatus field's value.
func (s *DirectoryDescription) SetRadiusStatus(v string) *DirectoryDescription {
	s.RadiusStatus = &v
	return s
}

// SetShortName sets the ShortName field's value.
func (s *DirectoryDescription) SetShortName(v string) *DirectoryDescription {
	s.ShortName = &v
	return s
}

// SetSize sets the Size field's value.
func (s *DirectoryDescription) SetSize(v string) *DirectoryDescription {
	s.Size = &v
	return s
}

// SetSsoEnabled sets the SsoEnabled field's value.
func (s *DirectoryDescription) SetSsoEnabled(v bool) *DirectoryDescription {
	s.SsoEnabled = &v
	return s
}

// SetStage sets the Stage field's value.
func (s *DirectoryDescription) SetStage(v string) *DirectoryDescription {
	s.Stage = &v
	return s
}

// SetStageLastUpdatedDateTime sets the StageLastUpdatedDateTime field's value.
func (s *DirectoryDescription) SetStageLastUpdatedDateTime(v time.Time) *DirectoryDescription {
	s.StageLastUpdatedDateTime = &v
	return s
}

// SetStageReason sets the StageReason field's value.
func (s *DirectoryDescription) SetStageReason(v string) *DirectoryDescription {
	s.StageReason = &v
	return s
}

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

// SetVpcSettings sets the VpcSettings field's value.
func (s *DirectoryDescription) SetVpcSettings(v *DirectoryVpcSettingsDescription) *DirectoryDescription {
	s.VpcSettings = v
	return s
}

// Contains directory limit information for a region.
type DirectoryLimits struct {
	_ struct{} `type:"structure"`

	// The current number of cloud directories in the region.
	CloudOnlyDirectoriesCurrentCount *int64 `type:"integer"`

	// The maximum number of cloud directories allowed in the region.
	CloudOnlyDirectoriesLimit *int64 `type:"integer"`

	// Indicates if the cloud directory limit has been reached.
	CloudOnlyDirectoriesLimitReached *bool `type:"boolean"`

	// The current number of Microsoft AD directories in the region.
	CloudOnlyMicrosoftADCurrentCount *int64 `type:"integer"`

	// The maximum number of Microsoft AD directories allowed in the region.
	CloudOnlyMicrosoftADLimit *int64 `type:"integer"`

	// Indicates if the Microsoft AD directory limit has been reached.
	CloudOnlyMicrosoftADLimitReached *bool `type:"boolean"`

	// The current number of connected directories in the region.
	ConnectedDirectoriesCurrentCount *int64 `type:"integer"`

	// The maximum number of connected directories allowed in the region.
	ConnectedDirectoriesLimit *int64 `type:"integer"`

	// Indicates if the connected directory limit has been reached.
	ConnectedDirectoriesLimitReached *bool `type:"boolean"`
}

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

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

// SetCloudOnlyDirectoriesCurrentCount sets the CloudOnlyDirectoriesCurrentCount field's value.
func (s *DirectoryLimits) SetCloudOnlyDirectoriesCurrentCount(v int64) *DirectoryLimits {
	s.CloudOnlyDirectoriesCurrentCount = &v
	return s
}

// SetCloudOnlyDirectoriesLimit sets the CloudOnlyDirectoriesLimit field's value.
func (s *DirectoryLimits) SetCloudOnlyDirectoriesLimit(v int64) *DirectoryLimits {
	s.CloudOnlyDirectoriesLimit = &v
	return s
}

// SetCloudOnlyDirectoriesLimitReached sets the CloudOnlyDirectoriesLimitReached field's value.
func (s *DirectoryLimits) SetCloudOnlyDirectoriesLimitReached(v bool) *DirectoryLimits {
	s.CloudOnlyDirectoriesLimitReached = &v
	return s
}

// SetCloudOnlyMicrosoftADCurrentCount sets the CloudOnlyMicrosoftADCurrentCount field's value.
func (s *DirectoryLimits) SetCloudOnlyMicrosoftADCurrentCount(v int64) *DirectoryLimits {
	s.CloudOnlyMicrosoftADCurrentCount = &v
	return s
}

// SetCloudOnlyMicrosoftADLimit sets the CloudOnlyMicrosoftADLimit field's value.
func (s *DirectoryLimits) SetCloudOnlyMicrosoftADLimit(v int64) *DirectoryLimits {
	s.CloudOnlyMicrosoftADLimit = &v
	return s
}

// SetCloudOnlyMicrosoftADLimitReached sets the CloudOnlyMicrosoftADLimitReached field's value.
func (s *DirectoryLimits) SetCloudOnlyMicrosoftADLimitReached(v bool) *DirectoryLimits {
	s.CloudOnlyMicrosoftADLimitReached = &v
	return s
}

// SetConnectedDirectoriesCurrentCount sets the ConnectedDirectoriesCurrentCount field's value.
func (s *DirectoryLimits) SetConnectedDirectoriesCurrentCount(v int64) *DirectoryLimits {
	s.ConnectedDirectoriesCurrentCount = &v
	return s
}

// SetConnectedDirectoriesLimit sets the ConnectedDirectoriesLimit field's value.
func (s *DirectoryLimits) SetConnectedDirectoriesLimit(v int64) *DirectoryLimits {
	s.ConnectedDirectoriesLimit = &v
	return s
}

// SetConnectedDirectoriesLimitReached sets the ConnectedDirectoriesLimitReached field's value.
func (s *DirectoryLimits) SetConnectedDirectoriesLimitReached(v bool) *DirectoryLimits {
	s.ConnectedDirectoriesLimitReached = &v
	return s
}

// Contains VPC information for the CreateDirectory or CreateMicrosoftAD operation.
type DirectoryVpcSettings struct {
	_ struct{} `type:"structure"`

	// The identifiers of the subnets for the directory servers. The two subnets
	// must be in different Availability Zones. AWS Directory Service creates a
	// directory server and a DNS server in each of these subnets.
	//
	// SubnetIds is a required field
	SubnetIds []*string `type:"list" required:"true"`

	// The identifier of the VPC in which to create the directory.
	//
	// VpcId is a required field
	VpcId *string `type:"string" required:"true"`
}

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

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

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

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

// SetSubnetIds sets the SubnetIds field's value.
func (s *DirectoryVpcSettings) SetSubnetIds(v []*string) *DirectoryVpcSettings {
	s.SubnetIds = v
	return s
}

// SetVpcId sets the VpcId field's value.
func (s *DirectoryVpcSettings) SetVpcId(v string) *DirectoryVpcSettings {
	s.VpcId = &v
	return s
}

// Contains information about the directory.
type DirectoryVpcSettingsDescription struct {
	_ struct{} `type:"structure"`

	// The list of Availability Zones that the directory is in.
	AvailabilityZones []*string `type:"list"`

	// The domain controller security group identifier for the directory.
	SecurityGroupId *string `type:"string"`

	// The identifiers of the subnets for the directory servers.
	SubnetIds []*string `type:"list"`

	// The identifier of the VPC that the directory is in.
	VpcId *string `type:"string"`
}

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

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

// SetAvailabilityZones sets the AvailabilityZones field's value.
func (s *DirectoryVpcSettingsDescription) SetAvailabilityZones(v []*string) *DirectoryVpcSettingsDescription {
	s.AvailabilityZones = v
	return s
}

// SetSecurityGroupId sets the SecurityGroupId field's value.
func (s *DirectoryVpcSettingsDescription) SetSecurityGroupId(v string) *DirectoryVpcSettingsDescription {
	s.SecurityGroupId = &v
	return s
}

// SetSubnetIds sets the SubnetIds field's value.
func (s *DirectoryVpcSettingsDescription) SetSubnetIds(v []*string) *DirectoryVpcSettingsDescription {
	s.SubnetIds = v
	return s
}

// SetVpcId sets the VpcId field's value.
func (s *DirectoryVpcSettingsDescription) SetVpcId(v string) *DirectoryVpcSettingsDescription {
	s.VpcId = &v
	return s
}

// Contains the inputs for the DisableRadius operation.
type DisableRadiusInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory for which to disable MFA.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DisableRadiusInput) SetDirectoryId(v string) *DisableRadiusInput {
	s.DirectoryId = &v
	return s
}

// Contains the results of the DisableRadius operation.
type DisableRadiusOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// Contains the inputs for the DisableSso operation.
type DisableSsoInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory for which to disable single-sign on.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The password of an alternate account to use to disable single-sign on. This
	// is only used for AD Connector directories. For more information, see the
	// UserName parameter.
	Password *string `min:"1" type:"string"`

	// The username of an alternate account to use to disable single-sign on. This
	// is only used for AD Connector directories. This account must have privileges
	// to remove a service principal name.
	//
	// If the AD Connector service account does not have privileges to remove a
	// service principal name, you can specify an alternate account with the UserName
	// and Password parameters. These credentials are only used to disable single
	// sign-on and are not stored by the service. The AD Connector service account
	// is not changed.
	UserName *string `min:"1" type:"string"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *DisableSsoInput) SetDirectoryId(v string) *DisableSsoInput {
	s.DirectoryId = &v
	return s
}

// SetPassword sets the Password field's value.
func (s *DisableSsoInput) SetPassword(v string) *DisableSsoInput {
	s.Password = &v
	return s
}

// SetUserName sets the UserName field's value.
func (s *DisableSsoInput) SetUserName(v string) *DisableSsoInput {
	s.UserName = &v
	return s
}

// Contains the results of the DisableSso operation.
type DisableSsoOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// Contains information about the domain controllers for a specified directory.
type DomainController struct {
	_ struct{} `type:"structure"`

	// The Availability Zone where the domain controller is located.
	AvailabilityZone *string `type:"string"`

	// Identifier of the directory where the domain controller resides.
	DirectoryId *string `type:"string"`

	// The IP address of the domain controller.
	DnsIpAddr *string `type:"string"`

	// Identifies a specific domain controller in the directory.
	DomainControllerId *string `type:"string"`

	// Specifies when the domain controller was created.
	LaunchTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The status of the domain controller.
	Status *string `type:"string" enum:"DomainControllerStatus"`

	// The date and time that the status was last updated.
	StatusLastUpdatedDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A description of the domain controller state.
	StatusReason *string `type:"string"`

	// Identifier of the subnet in the VPC that contains the domain controller.
	SubnetId *string `type:"string"`

	// The identifier of the VPC that contains the domain controller.
	VpcId *string `type:"string"`
}

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

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

// SetAvailabilityZone sets the AvailabilityZone field's value.
func (s *DomainController) SetAvailabilityZone(v string) *DomainController {
	s.AvailabilityZone = &v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *DomainController) SetDirectoryId(v string) *DomainController {
	s.DirectoryId = &v
	return s
}

// SetDnsIpAddr sets the DnsIpAddr field's value.
func (s *DomainController) SetDnsIpAddr(v string) *DomainController {
	s.DnsIpAddr = &v
	return s
}

// SetDomainControllerId sets the DomainControllerId field's value.
func (s *DomainController) SetDomainControllerId(v string) *DomainController {
	s.DomainControllerId = &v
	return s
}

// SetLaunchTime sets the LaunchTime field's value.
func (s *DomainController) SetLaunchTime(v time.Time) *DomainController {
	s.LaunchTime = &v
	return s
}

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

// SetStatusLastUpdatedDateTime sets the StatusLastUpdatedDateTime field's value.
func (s *DomainController) SetStatusLastUpdatedDateTime(v time.Time) *DomainController {
	s.StatusLastUpdatedDateTime = &v
	return s
}

// SetStatusReason sets the StatusReason field's value.
func (s *DomainController) SetStatusReason(v string) *DomainController {
	s.StatusReason = &v
	return s
}

// SetSubnetId sets the SubnetId field's value.
func (s *DomainController) SetSubnetId(v string) *DomainController {
	s.SubnetId = &v
	return s
}

// SetVpcId sets the VpcId field's value.
func (s *DomainController) SetVpcId(v string) *DomainController {
	s.VpcId = &v
	return s
}

// Contains the inputs for the EnableRadius operation.
type EnableRadiusInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory for which to enable MFA.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// A RadiusSettings object that contains information about the RADIUS server.
	//
	// RadiusSettings is a required field
	RadiusSettings *RadiusSettings `type:"structure" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *EnableRadiusInput) SetDirectoryId(v string) *EnableRadiusInput {
	s.DirectoryId = &v
	return s
}

// SetRadiusSettings sets the RadiusSettings field's value.
func (s *EnableRadiusInput) SetRadiusSettings(v *RadiusSettings) *EnableRadiusInput {
	s.RadiusSettings = v
	return s
}

// Contains the results of the EnableRadius operation.
type EnableRadiusOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// Contains the inputs for the EnableSso operation.
type EnableSsoInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory for which to enable single-sign on.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The password of an alternate account to use to enable single-sign on. This
	// is only used for AD Connector directories. For more information, see the
	// UserName parameter.
	Password *string `min:"1" type:"string"`

	// The username of an alternate account to use to enable single-sign on. This
	// is only used for AD Connector directories. This account must have privileges
	// to add a service principal name.
	//
	// If the AD Connector service account does not have privileges to add a service
	// principal name, you can specify an alternate account with the UserName and
	// Password parameters. These credentials are only used to enable single sign-on
	// and are not stored by the service. The AD Connector service account is not
	// changed.
	UserName *string `min:"1" type:"string"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *EnableSsoInput) SetDirectoryId(v string) *EnableSsoInput {
	s.DirectoryId = &v
	return s
}

// SetPassword sets the Password field's value.
func (s *EnableSsoInput) SetPassword(v string) *EnableSsoInput {
	s.Password = &v
	return s
}

// SetUserName sets the UserName field's value.
func (s *EnableSsoInput) SetUserName(v string) *EnableSsoInput {
	s.UserName = &v
	return s
}

// Contains the results of the EnableSso operation.
type EnableSsoOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// Information about SNS topic and AWS Directory Service directory associations.
type EventTopic struct {
	_ struct{} `type:"structure"`

	// The date and time of when you associated your directory with the SNS topic.
	CreatedDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Directory ID of an AWS Directory Service directory that will publish
	// status messages to an SNS topic.
	DirectoryId *string `type:"string"`

	// The topic registration status.
	Status *string `type:"string" enum:"TopicStatus"`

	// The SNS topic ARN (Amazon Resource Name).
	TopicArn *string `type:"string"`

	// The name of an AWS SNS topic the receives status messages from the directory.
	TopicName *string `min:"1" type:"string"`
}

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

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

// SetCreatedDateTime sets the CreatedDateTime field's value.
func (s *EventTopic) SetCreatedDateTime(v time.Time) *EventTopic {
	s.CreatedDateTime = &v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *EventTopic) SetDirectoryId(v string) *EventTopic {
	s.DirectoryId = &v
	return s
}

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

// SetTopicArn sets the TopicArn field's value.
func (s *EventTopic) SetTopicArn(v string) *EventTopic {
	s.TopicArn = &v
	return s
}

// SetTopicName sets the TopicName field's value.
func (s *EventTopic) SetTopicName(v string) *EventTopic {
	s.TopicName = &v
	return s
}

// Contains the inputs for the GetDirectoryLimits operation.
type GetDirectoryLimitsInput struct {
	_ struct{} `type:"structure"`
}

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

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

// Contains the results of the GetDirectoryLimits operation.
type GetDirectoryLimitsOutput struct {
	_ struct{} `type:"structure"`

	// A DirectoryLimits object that contains the directory limits for the current
	// region.
	DirectoryLimits *DirectoryLimits `type:"structure"`
}

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

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

// SetDirectoryLimits sets the DirectoryLimits field's value.
func (s *GetDirectoryLimitsOutput) SetDirectoryLimits(v *DirectoryLimits) *GetDirectoryLimitsOutput {
	s.DirectoryLimits = v
	return s
}

// Contains the inputs for the GetSnapshotLimits operation.
type GetSnapshotLimitsInput struct {
	_ struct{} `type:"structure"`

	// Contains the identifier of the directory to obtain the limits for.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *GetSnapshotLimitsInput) SetDirectoryId(v string) *GetSnapshotLimitsInput {
	s.DirectoryId = &v
	return s
}

// Contains the results of the GetSnapshotLimits operation.
type GetSnapshotLimitsOutput struct {
	_ struct{} `type:"structure"`

	// A SnapshotLimits object that contains the manual snapshot limits for the
	// specified directory.
	SnapshotLimits *SnapshotLimits `type:"structure"`
}

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

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

// SetSnapshotLimits sets the SnapshotLimits field's value.
func (s *GetSnapshotLimitsOutput) SetSnapshotLimits(v *SnapshotLimits) *GetSnapshotLimitsOutput {
	s.SnapshotLimits = v
	return s
}

// IP address block. This is often the address block of the DNS server used
// for your on-premises domain.
type IpRoute struct {
	_ struct{} `type:"structure"`

	// IP address block using CIDR format, for example 10.0.0.0/24. This is often
	// the address block of the DNS server used for your on-premises domain. For
	// a single IP address use a CIDR address block with /32. For example 10.0.0.0/32.
	CidrIp *string `type:"string"`

	// Description of the address block.
	Description *string `type:"string"`
}

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

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

// SetCidrIp sets the CidrIp field's value.
func (s *IpRoute) SetCidrIp(v string) *IpRoute {
	s.CidrIp = &v
	return s
}

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

// Information about one or more IP address blocks.
type IpRouteInfo struct {
	_ struct{} `type:"structure"`

	// The date and time the address block was added to the directory.
	AddedDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// IP address block in the IpRoute.
	CidrIp *string `type:"string"`

	// Description of the IpRouteInfo.
	Description *string `type:"string"`

	// Identifier (ID) of the directory associated with the IP addresses.
	DirectoryId *string `type:"string"`

	// The status of the IP address block.
	IpRouteStatusMsg *string `type:"string" enum:"IpRouteStatusMsg"`

	// The reason for the IpRouteStatusMsg.
	IpRouteStatusReason *string `type:"string"`
}

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

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

// SetAddedDateTime sets the AddedDateTime field's value.
func (s *IpRouteInfo) SetAddedDateTime(v time.Time) *IpRouteInfo {
	s.AddedDateTime = &v
	return s
}

// SetCidrIp sets the CidrIp field's value.
func (s *IpRouteInfo) SetCidrIp(v string) *IpRouteInfo {
	s.CidrIp = &v
	return s
}

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *IpRouteInfo) SetDirectoryId(v string) *IpRouteInfo {
	s.DirectoryId = &v
	return s
}

// SetIpRouteStatusMsg sets the IpRouteStatusMsg field's value.
func (s *IpRouteInfo) SetIpRouteStatusMsg(v string) *IpRouteInfo {
	s.IpRouteStatusMsg = &v
	return s
}

// SetIpRouteStatusReason sets the IpRouteStatusReason field's value.
func (s *IpRouteInfo) SetIpRouteStatusReason(v string) *IpRouteInfo {
	s.IpRouteStatusReason = &v
	return s
}

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

	// Identifier (ID) of the directory for which you want to retrieve the IP addresses.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// Maximum number of items to return. If this value is zero, the maximum number
	// of items is specified by the limitations of the operation.
	Limit *int64 `type:"integer"`

	// The ListIpRoutes.NextToken value from a previous call to ListIpRoutes. Pass
	// null if this is the first call.
	NextToken *string `type:"string"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *ListIpRoutesInput) SetDirectoryId(v string) *ListIpRoutesInput {
	s.DirectoryId = &v
	return s
}

// SetLimit sets the Limit field's value.
func (s *ListIpRoutesInput) SetLimit(v int64) *ListIpRoutesInput {
	s.Limit = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListIpRoutesInput) SetNextToken(v string) *ListIpRoutesInput {
	s.NextToken = &v
	return s
}

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

	// A list of IpRoutes.
	IpRoutesInfo []*IpRouteInfo `type:"list"`

	// If not null, more results are available. Pass this value for the NextToken
	// parameter in a subsequent call to ListIpRoutes to retrieve the next set of
	// items.
	NextToken *string `type:"string"`
}

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

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

// SetIpRoutesInfo sets the IpRoutesInfo field's value.
func (s *ListIpRoutesOutput) SetIpRoutesInfo(v []*IpRouteInfo) *ListIpRoutesOutput {
	s.IpRoutesInfo = v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListIpRoutesOutput) SetNextToken(v string) *ListIpRoutesOutput {
	s.NextToken = &v
	return s
}

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

	// The identifier of the directory from which to retrieve the schema extension
	// information.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The maximum number of items to return.
	Limit *int64 `type:"integer"`

	// The ListSchemaExtensions.NextToken value from a previous call to ListSchemaExtensions.
	// Pass null if this is the first call.
	NextToken *string `type:"string"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *ListSchemaExtensionsInput) SetDirectoryId(v string) *ListSchemaExtensionsInput {
	s.DirectoryId = &v
	return s
}

// SetLimit sets the Limit field's value.
func (s *ListSchemaExtensionsInput) SetLimit(v int64) *ListSchemaExtensionsInput {
	s.Limit = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListSchemaExtensionsInput) SetNextToken(v string) *ListSchemaExtensionsInput {
	s.NextToken = &v
	return s
}

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

	// If not null, more results are available. Pass this value for the NextToken
	// parameter in a subsequent call to ListSchemaExtensions to retrieve the next
	// set of items.
	NextToken *string `type:"string"`

	// Information about the schema extensions applied to the directory.
	SchemaExtensionsInfo []*SchemaExtensionInfo `type:"list"`
}

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

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

// SetNextToken sets the NextToken field's value.
func (s *ListSchemaExtensionsOutput) SetNextToken(v string) *ListSchemaExtensionsOutput {
	s.NextToken = &v
	return s
}

// SetSchemaExtensionsInfo sets the SchemaExtensionsInfo field's value.
func (s *ListSchemaExtensionsOutput) SetSchemaExtensionsInfo(v []*SchemaExtensionInfo) *ListSchemaExtensionsOutput {
	s.SchemaExtensionsInfo = v
	return s
}

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

	// Reserved for future use.
	Limit *int64 `type:"integer"`

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

	// Identifier (ID) of the directory for which you want to retrieve tags.
	//
	// ResourceId is a required field
	ResourceId *string `type:"string" required:"true"`
}

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

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

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

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

// SetLimit sets the Limit field's value.
func (s *ListTagsForResourceInput) SetLimit(v int64) *ListTagsForResourceInput {
	s.Limit = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *ListTagsForResourceInput) SetNextToken(v string) *ListTagsForResourceInput {
	s.NextToken = &v
	return s
}

// SetResourceId sets the ResourceId field's value.
func (s *ListTagsForResourceInput) SetResourceId(v string) *ListTagsForResourceInput {
	s.ResourceId = &v
	return s
}

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

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

	// List of tags returned by the ListTagsForResource operation.
	Tags []*Tag `type:"list"`
}

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

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

// SetNextToken sets the NextToken field's value.
func (s *ListTagsForResourceOutput) SetNextToken(v string) *ListTagsForResourceOutput {
	s.NextToken = &v
	return s
}

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

// Contains information about a Remote Authentication Dial In User Service (RADIUS)
// server.
type RadiusSettings struct {
	_ struct{} `type:"structure"`

	// The protocol specified for your RADIUS endpoints.
	AuthenticationProtocol *string `type:"string" enum:"RadiusAuthenticationProtocol"`

	// Not currently used.
	DisplayLabel *string `min:"1" type:"string"`

	// The port that your RADIUS server is using for communications. Your on-premises
	// network must allow inbound traffic over this port from the AWS Directory
	// Service servers.
	RadiusPort *int64 `min:"1025" type:"integer"`

	// The maximum number of times that communication with the RADIUS server is
	// attempted.
	RadiusRetries *int64 `type:"integer"`

	// An array of strings that contains the IP addresses of the RADIUS server endpoints,
	// or the IP addresses of your RADIUS server load balancer.
	RadiusServers []*string `type:"list"`

	// The amount of time, in seconds, to wait for the RADIUS server to respond.
	RadiusTimeout *int64 `min:"1" type:"integer"`

	// Not currently used.
	SharedSecret *string `min:"8" type:"string"`

	// Not currently used.
	UseSameUsername *bool `type:"boolean"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *RadiusSettings) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "RadiusSettings"}
	if s.DisplayLabel != nil && len(*s.DisplayLabel) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("DisplayLabel", 1))
	}
	if s.RadiusPort != nil && *s.RadiusPort < 1025 {
		invalidParams.Add(request.NewErrParamMinValue("RadiusPort", 1025))
	}
	if s.RadiusTimeout != nil && *s.RadiusTimeout < 1 {
		invalidParams.Add(request.NewErrParamMinValue("RadiusTimeout", 1))
	}
	if s.SharedSecret != nil && len(*s.SharedSecret) < 8 {
		invalidParams.Add(request.NewErrParamMinLen("SharedSecret", 8))
	}

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

// SetAuthenticationProtocol sets the AuthenticationProtocol field's value.
func (s *RadiusSettings) SetAuthenticationProtocol(v string) *RadiusSettings {
	s.AuthenticationProtocol = &v
	return s
}

// SetDisplayLabel sets the DisplayLabel field's value.
func (s *RadiusSettings) SetDisplayLabel(v string) *RadiusSettings {
	s.DisplayLabel = &v
	return s
}

// SetRadiusPort sets the RadiusPort field's value.
func (s *RadiusSettings) SetRadiusPort(v int64) *RadiusSettings {
	s.RadiusPort = &v
	return s
}

// SetRadiusRetries sets the RadiusRetries field's value.
func (s *RadiusSettings) SetRadiusRetries(v int64) *RadiusSettings {
	s.RadiusRetries = &v
	return s
}

// SetRadiusServers sets the RadiusServers field's value.
func (s *RadiusSettings) SetRadiusServers(v []*string) *RadiusSettings {
	s.RadiusServers = v
	return s
}

// SetRadiusTimeout sets the RadiusTimeout field's value.
func (s *RadiusSettings) SetRadiusTimeout(v int64) *RadiusSettings {
	s.RadiusTimeout = &v
	return s
}

// SetSharedSecret sets the SharedSecret field's value.
func (s *RadiusSettings) SetSharedSecret(v string) *RadiusSettings {
	s.SharedSecret = &v
	return s
}

// SetUseSameUsername sets the UseSameUsername field's value.
func (s *RadiusSettings) SetUseSameUsername(v bool) *RadiusSettings {
	s.UseSameUsername = &v
	return s
}

// Registers a new event topic.
type RegisterEventTopicInput struct {
	_ struct{} `type:"structure"`

	// The Directory ID that will publish status messages to the SNS topic.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The SNS topic name to which the directory will publish status messages. This
	// SNS topic must be in the same region as the specified Directory ID.
	//
	// TopicName is a required field
	TopicName *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *RegisterEventTopicInput) SetDirectoryId(v string) *RegisterEventTopicInput {
	s.DirectoryId = &v
	return s
}

// SetTopicName sets the TopicName field's value.
func (s *RegisterEventTopicInput) SetTopicName(v string) *RegisterEventTopicInput {
	s.TopicName = &v
	return s
}

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

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

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

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

	// IP address blocks that you want to remove.
	//
	// CidrIps is a required field
	CidrIps []*string `type:"list" required:"true"`

	// Identifier (ID) of the directory from which you want to remove the IP addresses.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`
}

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

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

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

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

// SetCidrIps sets the CidrIps field's value.
func (s *RemoveIpRoutesInput) SetCidrIps(v []*string) *RemoveIpRoutesInput {
	s.CidrIps = v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *RemoveIpRoutesInput) SetDirectoryId(v string) *RemoveIpRoutesInput {
	s.DirectoryId = &v
	return s
}

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

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

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

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

	// Identifier (ID) of the directory from which to remove the tag.
	//
	// ResourceId is a required field
	ResourceId *string `type:"string" required:"true"`

	// The tag key (name) of the tag to be removed.
	//
	// TagKeys is a required field
	TagKeys []*string `type:"list" required:"true"`
}

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

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

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

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

// SetResourceId sets the ResourceId field's value.
func (s *RemoveTagsFromResourceInput) SetResourceId(v string) *RemoveTagsFromResourceInput {
	s.ResourceId = &v
	return s
}

// SetTagKeys sets the TagKeys field's value.
func (s *RemoveTagsFromResourceInput) SetTagKeys(v []*string) *RemoveTagsFromResourceInput {
	s.TagKeys = v
	return s
}

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

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

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

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

	// Identifier of the AWS Managed Microsoft AD or Simple AD directory in which
	// the user resides.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The new password that will be reset.
	//
	// NewPassword is a required field
	NewPassword *string `min:"1" type:"string" required:"true"`

	// The username of the user whose password will be reset.
	//
	// UserName is a required field
	UserName *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *ResetUserPasswordInput) SetDirectoryId(v string) *ResetUserPasswordInput {
	s.DirectoryId = &v
	return s
}

// SetNewPassword sets the NewPassword field's value.
func (s *ResetUserPasswordInput) SetNewPassword(v string) *ResetUserPasswordInput {
	s.NewPassword = &v
	return s
}

// SetUserName sets the UserName field's value.
func (s *ResetUserPasswordInput) SetUserName(v string) *ResetUserPasswordInput {
	s.UserName = &v
	return s
}

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

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

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

// An object representing the inputs for the RestoreFromSnapshot operation.
type RestoreFromSnapshotInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the snapshot to restore from.
	//
	// SnapshotId is a required field
	SnapshotId *string `type:"string" required:"true"`
}

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

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

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

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

// SetSnapshotId sets the SnapshotId field's value.
func (s *RestoreFromSnapshotInput) SetSnapshotId(v string) *RestoreFromSnapshotInput {
	s.SnapshotId = &v
	return s
}

// Contains the results of the RestoreFromSnapshot operation.
type RestoreFromSnapshotOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// Information about a schema extension.
type SchemaExtensionInfo struct {
	_ struct{} `type:"structure"`

	// A description of the schema extension.
	Description *string `type:"string"`

	// The identifier of the directory to which the schema extension is applied.
	DirectoryId *string `type:"string"`

	// The date and time that the schema extension was completed.
	EndDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The identifier of the schema extension.
	SchemaExtensionId *string `type:"string"`

	// The current status of the schema extension.
	SchemaExtensionStatus *string `type:"string" enum:"SchemaExtensionStatus"`

	// The reason for the SchemaExtensionStatus.
	SchemaExtensionStatusReason *string `type:"string"`

	// The date and time that the schema extension started being applied to the
	// directory.
	StartDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`
}

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *SchemaExtensionInfo) SetDirectoryId(v string) *SchemaExtensionInfo {
	s.DirectoryId = &v
	return s
}

// SetEndDateTime sets the EndDateTime field's value.
func (s *SchemaExtensionInfo) SetEndDateTime(v time.Time) *SchemaExtensionInfo {
	s.EndDateTime = &v
	return s
}

// SetSchemaExtensionId sets the SchemaExtensionId field's value.
func (s *SchemaExtensionInfo) SetSchemaExtensionId(v string) *SchemaExtensionInfo {
	s.SchemaExtensionId = &v
	return s
}

// SetSchemaExtensionStatus sets the SchemaExtensionStatus field's value.
func (s *SchemaExtensionInfo) SetSchemaExtensionStatus(v string) *SchemaExtensionInfo {
	s.SchemaExtensionStatus = &v
	return s
}

// SetSchemaExtensionStatusReason sets the SchemaExtensionStatusReason field's value.
func (s *SchemaExtensionInfo) SetSchemaExtensionStatusReason(v string) *SchemaExtensionInfo {
	s.SchemaExtensionStatusReason = &v
	return s
}

// SetStartDateTime sets the StartDateTime field's value.
func (s *SchemaExtensionInfo) SetStartDateTime(v time.Time) *SchemaExtensionInfo {
	s.StartDateTime = &v
	return s
}

// Describes a directory snapshot.
type Snapshot struct {
	_ struct{} `type:"structure"`

	// The directory identifier.
	DirectoryId *string `type:"string"`

	// The descriptive name of the snapshot.
	Name *string `type:"string"`

	// The snapshot identifier.
	SnapshotId *string `type:"string"`

	// The date and time that the snapshot was taken.
	StartTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The snapshot status.
	Status *string `type:"string" enum:"SnapshotStatus"`

	// The snapshot type.
	Type *string `type:"string" enum:"SnapshotType"`
}

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *Snapshot) SetDirectoryId(v string) *Snapshot {
	s.DirectoryId = &v
	return s
}

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

// SetSnapshotId sets the SnapshotId field's value.
func (s *Snapshot) SetSnapshotId(v string) *Snapshot {
	s.SnapshotId = &v
	return s
}

// SetStartTime sets the StartTime field's value.
func (s *Snapshot) SetStartTime(v time.Time) *Snapshot {
	s.StartTime = &v
	return s
}

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

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

// Contains manual snapshot limit information for a directory.
type SnapshotLimits struct {
	_ struct{} `type:"structure"`

	// The current number of manual snapshots of the directory.
	ManualSnapshotsCurrentCount *int64 `type:"integer"`

	// The maximum number of manual snapshots allowed.
	ManualSnapshotsLimit *int64 `type:"integer"`

	// Indicates if the manual snapshot limit has been reached.
	ManualSnapshotsLimitReached *bool `type:"boolean"`
}

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

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

// SetManualSnapshotsCurrentCount sets the ManualSnapshotsCurrentCount field's value.
func (s *SnapshotLimits) SetManualSnapshotsCurrentCount(v int64) *SnapshotLimits {
	s.ManualSnapshotsCurrentCount = &v
	return s
}

// SetManualSnapshotsLimit sets the ManualSnapshotsLimit field's value.
func (s *SnapshotLimits) SetManualSnapshotsLimit(v int64) *SnapshotLimits {
	s.ManualSnapshotsLimit = &v
	return s
}

// SetManualSnapshotsLimitReached sets the ManualSnapshotsLimitReached field's value.
func (s *SnapshotLimits) SetManualSnapshotsLimitReached(v bool) *SnapshotLimits {
	s.ManualSnapshotsLimitReached = &v
	return s
}

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

	// If true, creates a snapshot of the directory before applying the schema extension.
	//
	// CreateSnapshotBeforeSchemaExtension is a required field
	CreateSnapshotBeforeSchemaExtension *bool `type:"boolean" required:"true"`

	// A description of the schema extension.
	//
	// Description is a required field
	Description *string `type:"string" required:"true"`

	// The identifier of the directory for which the schema extension will be applied
	// to.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The LDIF file represented as a string. To construct the LdifContent string,
	// precede each line as it would be formatted in an ldif file with \n. See the
	// example request below for more details. The file size can be no larger than
	// 1MB.
	//
	// LdifContent is a required field
	LdifContent *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

// SetCreateSnapshotBeforeSchemaExtension sets the CreateSnapshotBeforeSchemaExtension field's value.
func (s *StartSchemaExtensionInput) SetCreateSnapshotBeforeSchemaExtension(v bool) *StartSchemaExtensionInput {
	s.CreateSnapshotBeforeSchemaExtension = &v
	return s
}

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *StartSchemaExtensionInput) SetDirectoryId(v string) *StartSchemaExtensionInput {
	s.DirectoryId = &v
	return s
}

// SetLdifContent sets the LdifContent field's value.
func (s *StartSchemaExtensionInput) SetLdifContent(v string) *StartSchemaExtensionInput {
	s.LdifContent = &v
	return s
}

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

	// The identifier of the schema extension that will be applied.
	SchemaExtensionId *string `type:"string"`
}

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

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

// SetSchemaExtensionId sets the SchemaExtensionId field's value.
func (s *StartSchemaExtensionOutput) SetSchemaExtensionId(v string) *StartSchemaExtensionOutput {
	s.SchemaExtensionId = &v
	return s
}

// Metadata assigned to a directory consisting of a key-value pair.
type Tag struct {
	_ struct{} `type:"structure"`

	// Required name of the tag. The string value can be Unicode characters and
	// cannot be prefixed with "aws:". The string can contain only the set of Unicode
	// letters, digits, white-space, '_', '.', '/', '=', '+', '-' (Java regex: "^([\\p{L}\\p{Z}\\p{N}_.:/=+\\-]*)$").
	//
	// Key is a required field
	Key *string `min:"1" type:"string" required:"true"`

	// The optional value of the tag. The string value can be Unicode characters.
	// The string can contain only the set of Unicode letters, digits, white-space,
	// '_', '.', '/', '=', '+', '-' (Java regex: "^([\\p{L}\\p{Z}\\p{N}_.:/=+\\-]*)$").
	//
	// Value is a required field
	Value *string `type:"string" required:"true"`
}

// 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()
}

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

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

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

// Describes a trust relationship between an Microsoft AD in the AWS cloud and
// an external domain.
type Trust struct {
	_ struct{} `type:"structure"`

	// The date and time that the trust relationship was created.
	CreatedDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Directory ID of the AWS directory involved in the trust relationship.
	DirectoryId *string `type:"string"`

	// The date and time that the trust relationship was last updated.
	LastUpdatedDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The Fully Qualified Domain Name (FQDN) of the external domain involved in
	// the trust relationship.
	RemoteDomainName *string `type:"string"`

	// The date and time that the TrustState was last updated.
	StateLastUpdatedDateTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The trust relationship direction.
	TrustDirection *string `type:"string" enum:"TrustDirection"`

	// The unique ID of the trust relationship.
	TrustId *string `type:"string"`

	// The trust relationship state.
	TrustState *string `type:"string" enum:"TrustState"`

	// The reason for the TrustState.
	TrustStateReason *string `type:"string"`

	// The trust relationship type.
	TrustType *string `type:"string" enum:"TrustType"`
}

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

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

// SetCreatedDateTime sets the CreatedDateTime field's value.
func (s *Trust) SetCreatedDateTime(v time.Time) *Trust {
	s.CreatedDateTime = &v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *Trust) SetDirectoryId(v string) *Trust {
	s.DirectoryId = &v
	return s
}

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

// SetRemoteDomainName sets the RemoteDomainName field's value.
func (s *Trust) SetRemoteDomainName(v string) *Trust {
	s.RemoteDomainName = &v
	return s
}

// SetStateLastUpdatedDateTime sets the StateLastUpdatedDateTime field's value.
func (s *Trust) SetStateLastUpdatedDateTime(v time.Time) *Trust {
	s.StateLastUpdatedDateTime = &v
	return s
}

// SetTrustDirection sets the TrustDirection field's value.
func (s *Trust) SetTrustDirection(v string) *Trust {
	s.TrustDirection = &v
	return s
}

// SetTrustId sets the TrustId field's value.
func (s *Trust) SetTrustId(v string) *Trust {
	s.TrustId = &v
	return s
}

// SetTrustState sets the TrustState field's value.
func (s *Trust) SetTrustState(v string) *Trust {
	s.TrustState = &v
	return s
}

// SetTrustStateReason sets the TrustStateReason field's value.
func (s *Trust) SetTrustStateReason(v string) *Trust {
	s.TrustStateReason = &v
	return s
}

// SetTrustType sets the TrustType field's value.
func (s *Trust) SetTrustType(v string) *Trust {
	s.TrustType = &v
	return s
}

// Updates a conditional forwarder.
type UpdateConditionalForwarderInput struct {
	_ struct{} `type:"structure"`

	// The directory ID of the AWS directory for which to update the conditional
	// forwarder.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The updated IP addresses of the remote DNS server associated with the conditional
	// forwarder.
	//
	// DnsIpAddrs is a required field
	DnsIpAddrs []*string `type:"list" required:"true"`

	// The fully qualified domain name (FQDN) of the remote domain with which you
	// will set up a trust relationship.
	//
	// RemoteDomainName is a required field
	RemoteDomainName *string `type:"string" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *UpdateConditionalForwarderInput) SetDirectoryId(v string) *UpdateConditionalForwarderInput {
	s.DirectoryId = &v
	return s
}

// SetDnsIpAddrs sets the DnsIpAddrs field's value.
func (s *UpdateConditionalForwarderInput) SetDnsIpAddrs(v []*string) *UpdateConditionalForwarderInput {
	s.DnsIpAddrs = v
	return s
}

// SetRemoteDomainName sets the RemoteDomainName field's value.
func (s *UpdateConditionalForwarderInput) SetRemoteDomainName(v string) *UpdateConditionalForwarderInput {
	s.RemoteDomainName = &v
	return s
}

// The result of an UpdateConditionalForwarder request.
type UpdateConditionalForwarderOutput struct {
	_ struct{} `type:"structure"`
}

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

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

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

	// The number of domain controllers desired in the directory.
	//
	// DesiredNumber is a required field
	DesiredNumber *int64 `min:"2" type:"integer" required:"true"`

	// Identifier of the directory to which the domain controllers will be added
	// or removed.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`
}

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

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

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

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

// SetDesiredNumber sets the DesiredNumber field's value.
func (s *UpdateNumberOfDomainControllersInput) SetDesiredNumber(v int64) *UpdateNumberOfDomainControllersInput {
	s.DesiredNumber = &v
	return s
}

// SetDirectoryId sets the DirectoryId field's value.
func (s *UpdateNumberOfDomainControllersInput) SetDirectoryId(v string) *UpdateNumberOfDomainControllersInput {
	s.DirectoryId = &v
	return s
}

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

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

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

// Contains the inputs for the UpdateRadius operation.
type UpdateRadiusInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the directory for which to update the RADIUS server information.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// A RadiusSettings object that contains information about the RADIUS server.
	//
	// RadiusSettings is a required field
	RadiusSettings *RadiusSettings `type:"structure" required:"true"`
}

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

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

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

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

// SetDirectoryId sets the DirectoryId field's value.
func (s *UpdateRadiusInput) SetDirectoryId(v string) *UpdateRadiusInput {
	s.DirectoryId = &v
	return s
}

// SetRadiusSettings sets the RadiusSettings field's value.
func (s *UpdateRadiusInput) SetRadiusSettings(v *RadiusSettings) *UpdateRadiusInput {
	s.RadiusSettings = v
	return s
}

// Contains the results of the UpdateRadius operation.
type UpdateRadiusOutput struct {
	_ struct{} `type:"structure"`
}

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

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

// Initiates the verification of an existing trust relationship between a Microsoft
// AD in the AWS cloud and an external domain.
type VerifyTrustInput struct {
	_ struct{} `type:"structure"`

	// The unique Trust ID of the trust relationship to verify.
	//
	// TrustId is a required field
	TrustId *string `type:"string" required:"true"`
}

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

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

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

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

// SetTrustId sets the TrustId field's value.
func (s *VerifyTrustInput) SetTrustId(v string) *VerifyTrustInput {
	s.TrustId = &v
	return s
}

// Result of a VerifyTrust request.
type VerifyTrustOutput struct {
	_ struct{} `type:"structure"`

	// The unique Trust ID of the trust relationship that was verified.
	TrustId *string `type:"string"`
}

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

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

// SetTrustId sets the TrustId field's value.
func (s *VerifyTrustOutput) SetTrustId(v string) *VerifyTrustOutput {
	s.TrustId = &v
	return s
}

const (
	// DirectoryEditionEnterprise is a DirectoryEdition enum value
	DirectoryEditionEnterprise = "Enterprise"

	// DirectoryEditionStandard is a DirectoryEdition enum value
	DirectoryEditionStandard = "Standard"
)

const (
	// DirectorySizeSmall is a DirectorySize enum value
	DirectorySizeSmall = "Small"

	// DirectorySizeLarge is a DirectorySize enum value
	DirectorySizeLarge = "Large"
)

const (
	// DirectoryStageRequested is a DirectoryStage enum value
	DirectoryStageRequested = "Requested"

	// DirectoryStageCreating is a DirectoryStage enum value
	DirectoryStageCreating = "Creating"

	// DirectoryStageCreated is a DirectoryStage enum value
	DirectoryStageCreated = "Created"

	// DirectoryStageActive is a DirectoryStage enum value
	DirectoryStageActive = "Active"

	// DirectoryStageInoperable is a DirectoryStage enum value
	DirectoryStageInoperable = "Inoperable"

	// DirectoryStageImpaired is a DirectoryStage enum value
	DirectoryStageImpaired = "Impaired"

	// DirectoryStageRestoring is a DirectoryStage enum value
	DirectoryStageRestoring = "Restoring"

	// DirectoryStageRestoreFailed is a DirectoryStage enum value
	DirectoryStageRestoreFailed = "RestoreFailed"

	// DirectoryStageDeleting is a DirectoryStage enum value
	DirectoryStageDeleting = "Deleting"

	// DirectoryStageDeleted is a DirectoryStage enum value
	DirectoryStageDeleted = "Deleted"

	// DirectoryStageFailed is a DirectoryStage enum value
	DirectoryStageFailed = "Failed"
)

const (
	// DirectoryTypeSimpleAd is a DirectoryType enum value
	DirectoryTypeSimpleAd = "SimpleAD"

	// DirectoryTypeAdconnector is a DirectoryType enum value
	DirectoryTypeAdconnector = "ADConnector"

	// DirectoryTypeMicrosoftAd is a DirectoryType enum value
	DirectoryTypeMicrosoftAd = "MicrosoftAD"
)

const (
	// DomainControllerStatusCreating is a DomainControllerStatus enum value
	DomainControllerStatusCreating = "Creating"

	// DomainControllerStatusActive is a DomainControllerStatus enum value
	DomainControllerStatusActive = "Active"

	// DomainControllerStatusImpaired is a DomainControllerStatus enum value
	DomainControllerStatusImpaired = "Impaired"

	// DomainControllerStatusRestoring is a DomainControllerStatus enum value
	DomainControllerStatusRestoring = "Restoring"

	// DomainControllerStatusDeleting is a DomainControllerStatus enum value
	DomainControllerStatusDeleting = "Deleting"

	// DomainControllerStatusDeleted is a DomainControllerStatus enum value
	DomainControllerStatusDeleted = "Deleted"

	// DomainControllerStatusFailed is a DomainControllerStatus enum value
	DomainControllerStatusFailed = "Failed"
)

const (
	// IpRouteStatusMsgAdding is a IpRouteStatusMsg enum value
	IpRouteStatusMsgAdding = "Adding"

	// IpRouteStatusMsgAdded is a IpRouteStatusMsg enum value
	IpRouteStatusMsgAdded = "Added"

	// IpRouteStatusMsgRemoving is a IpRouteStatusMsg enum value
	IpRouteStatusMsgRemoving = "Removing"

	// IpRouteStatusMsgRemoved is a IpRouteStatusMsg enum value
	IpRouteStatusMsgRemoved = "Removed"

	// IpRouteStatusMsgAddFailed is a IpRouteStatusMsg enum value
	IpRouteStatusMsgAddFailed = "AddFailed"

	// IpRouteStatusMsgRemoveFailed is a IpRouteStatusMsg enum value
	IpRouteStatusMsgRemoveFailed = "RemoveFailed"
)

const (
	// RadiusAuthenticationProtocolPap is a RadiusAuthenticationProtocol enum value
	RadiusAuthenticationProtocolPap = "PAP"

	// RadiusAuthenticationProtocolChap is a RadiusAuthenticationProtocol enum value
	RadiusAuthenticationProtocolChap = "CHAP"

	// RadiusAuthenticationProtocolMsChapv1 is a RadiusAuthenticationProtocol enum value
	RadiusAuthenticationProtocolMsChapv1 = "MS-CHAPv1"

	// RadiusAuthenticationProtocolMsChapv2 is a RadiusAuthenticationProtocol enum value
	RadiusAuthenticationProtocolMsChapv2 = "MS-CHAPv2"
)

const (
	// RadiusStatusCreating is a RadiusStatus enum value
	RadiusStatusCreating = "Creating"

	// RadiusStatusCompleted is a RadiusStatus enum value
	RadiusStatusCompleted = "Completed"

	// RadiusStatusFailed is a RadiusStatus enum value
	RadiusStatusFailed = "Failed"
)

const (
	// ReplicationScopeDomain is a ReplicationScope enum value
	ReplicationScopeDomain = "Domain"
)

const (
	// SchemaExtensionStatusInitializing is a SchemaExtensionStatus enum value
	SchemaExtensionStatusInitializing = "Initializing"

	// SchemaExtensionStatusCreatingSnapshot is a SchemaExtensionStatus enum value
	SchemaExtensionStatusCreatingSnapshot = "CreatingSnapshot"

	// SchemaExtensionStatusUpdatingSchema is a SchemaExtensionStatus enum value
	SchemaExtensionStatusUpdatingSchema = "UpdatingSchema"

	// SchemaExtensionStatusReplicating is a SchemaExtensionStatus enum value
	SchemaExtensionStatusReplicating = "Replicating"

	// SchemaExtensionStatusCancelInProgress is a SchemaExtensionStatus enum value
	SchemaExtensionStatusCancelInProgress = "CancelInProgress"

	// SchemaExtensionStatusRollbackInProgress is a SchemaExtensionStatus enum value
	SchemaExtensionStatusRollbackInProgress = "RollbackInProgress"

	// SchemaExtensionStatusCancelled is a SchemaExtensionStatus enum value
	SchemaExtensionStatusCancelled = "Cancelled"

	// SchemaExtensionStatusFailed is a SchemaExtensionStatus enum value
	SchemaExtensionStatusFailed = "Failed"

	// SchemaExtensionStatusCompleted is a SchemaExtensionStatus enum value
	SchemaExtensionStatusCompleted = "Completed"
)

const (
	// SnapshotStatusCreating is a SnapshotStatus enum value
	SnapshotStatusCreating = "Creating"

	// SnapshotStatusCompleted is a SnapshotStatus enum value
	SnapshotStatusCompleted = "Completed"

	// SnapshotStatusFailed is a SnapshotStatus enum value
	SnapshotStatusFailed = "Failed"
)

const (
	// SnapshotTypeAuto is a SnapshotType enum value
	SnapshotTypeAuto = "Auto"

	// SnapshotTypeManual is a SnapshotType enum value
	SnapshotTypeManual = "Manual"
)

const (
	// TopicStatusRegistered is a TopicStatus enum value
	TopicStatusRegistered = "Registered"

	// TopicStatusTopicnotfound is a TopicStatus enum value
	TopicStatusTopicnotfound = "Topic not found"

	// TopicStatusFailed is a TopicStatus enum value
	TopicStatusFailed = "Failed"

	// TopicStatusDeleted is a TopicStatus enum value
	TopicStatusDeleted = "Deleted"
)

const (
	// TrustDirectionOneWayOutgoing is a TrustDirection enum value
	TrustDirectionOneWayOutgoing = "One-Way: Outgoing"

	// TrustDirectionOneWayIncoming is a TrustDirection enum value
	TrustDirectionOneWayIncoming = "One-Way: Incoming"

	// TrustDirectionTwoWay is a TrustDirection enum value
	TrustDirectionTwoWay = "Two-Way"
)

const (
	// TrustStateCreating is a TrustState enum value
	TrustStateCreating = "Creating"

	// TrustStateCreated is a TrustState enum value
	TrustStateCreated = "Created"

	// TrustStateVerifying is a TrustState enum value
	TrustStateVerifying = "Verifying"

	// TrustStateVerifyFailed is a TrustState enum value
	TrustStateVerifyFailed = "VerifyFailed"

	// TrustStateVerified is a TrustState enum value
	TrustStateVerified = "Verified"

	// TrustStateDeleting is a TrustState enum value
	TrustStateDeleting = "Deleting"

	// TrustStateDeleted is a TrustState enum value
	TrustStateDeleted = "Deleted"

	// TrustStateFailed is a TrustState enum value
	TrustStateFailed = "Failed"
)

const (
	// TrustTypeForest is a TrustType enum value
	TrustTypeForest = "Forest"
)