api.go

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

// Package directoryservice provides a client for AWS Directory Service.
package directoryservice

import (
	"sync"
	"time"

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

var oprw sync.Mutex

// ConnectDirectoryRequest generates a request for the ConnectDirectory operation.
func (c *DirectoryService) ConnectDirectoryRequest(input *ConnectDirectoryInput) (req *aws.Request, output *ConnectDirectoryOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opConnectDirectory == nil {
		opConnectDirectory = &aws.Operation{
			Name:       "ConnectDirectory",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Creates an AD Connector to connect an on-premises directory.
func (c *DirectoryService) ConnectDirectory(input *ConnectDirectoryInput) (*ConnectDirectoryOutput, error) {
	req, out := c.ConnectDirectoryRequest(input)
	err := req.Send()
	return out, err
}

var opConnectDirectory *aws.Operation

// CreateAliasRequest generates a request for the CreateAlias operation.
func (c *DirectoryService) CreateAliasRequest(input *CreateAliasInput) (req *aws.Request, output *CreateAliasOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opCreateAlias == nil {
		opCreateAlias = &aws.Operation{
			Name:       "CreateAlias",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// 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.
func (c *DirectoryService) CreateAlias(input *CreateAliasInput) (*CreateAliasOutput, error) {
	req, out := c.CreateAliasRequest(input)
	err := req.Send()
	return out, err
}

var opCreateAlias *aws.Operation

// CreateComputerRequest generates a request for the CreateComputer operation.
func (c *DirectoryService) CreateComputerRequest(input *CreateComputerInput) (req *aws.Request, output *CreateComputerOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opCreateComputer == nil {
		opCreateComputer = &aws.Operation{
			Name:       "CreateComputer",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Creates a computer account in the specified directory, and joins the computer
// to the directory.
func (c *DirectoryService) CreateComputer(input *CreateComputerInput) (*CreateComputerOutput, error) {
	req, out := c.CreateComputerRequest(input)
	err := req.Send()
	return out, err
}

var opCreateComputer *aws.Operation

// CreateDirectoryRequest generates a request for the CreateDirectory operation.
func (c *DirectoryService) CreateDirectoryRequest(input *CreateDirectoryInput) (req *aws.Request, output *CreateDirectoryOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opCreateDirectory == nil {
		opCreateDirectory = &aws.Operation{
			Name:       "CreateDirectory",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Creates a Simple AD directory.
func (c *DirectoryService) CreateDirectory(input *CreateDirectoryInput) (*CreateDirectoryOutput, error) {
	req, out := c.CreateDirectoryRequest(input)
	err := req.Send()
	return out, err
}

var opCreateDirectory *aws.Operation

// CreateSnapshotRequest generates a request for the CreateSnapshot operation.
func (c *DirectoryService) CreateSnapshotRequest(input *CreateSnapshotInput) (req *aws.Request, output *CreateSnapshotOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opCreateSnapshot == nil {
		opCreateSnapshot = &aws.Operation{
			Name:       "CreateSnapshot",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Creates a snapshot of an existing directory.
//
// You cannot take snapshots of extended or connected directories.
func (c *DirectoryService) CreateSnapshot(input *CreateSnapshotInput) (*CreateSnapshotOutput, error) {
	req, out := c.CreateSnapshotRequest(input)
	err := req.Send()
	return out, err
}

var opCreateSnapshot *aws.Operation

// DeleteDirectoryRequest generates a request for the DeleteDirectory operation.
func (c *DirectoryService) DeleteDirectoryRequest(input *DeleteDirectoryInput) (req *aws.Request, output *DeleteDirectoryOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDeleteDirectory == nil {
		opDeleteDirectory = &aws.Operation{
			Name:       "DeleteDirectory",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Deletes an AWS Directory Service directory.
func (c *DirectoryService) DeleteDirectory(input *DeleteDirectoryInput) (*DeleteDirectoryOutput, error) {
	req, out := c.DeleteDirectoryRequest(input)
	err := req.Send()
	return out, err
}

var opDeleteDirectory *aws.Operation

// DeleteSnapshotRequest generates a request for the DeleteSnapshot operation.
func (c *DirectoryService) DeleteSnapshotRequest(input *DeleteSnapshotInput) (req *aws.Request, output *DeleteSnapshotOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDeleteSnapshot == nil {
		opDeleteSnapshot = &aws.Operation{
			Name:       "DeleteSnapshot",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Deletes a directory snapshot.
func (c *DirectoryService) DeleteSnapshot(input *DeleteSnapshotInput) (*DeleteSnapshotOutput, error) {
	req, out := c.DeleteSnapshotRequest(input)
	err := req.Send()
	return out, err
}

var opDeleteSnapshot *aws.Operation

// DescribeDirectoriesRequest generates a request for the DescribeDirectories operation.
func (c *DirectoryService) DescribeDirectoriesRequest(input *DescribeDirectoriesInput) (req *aws.Request, output *DescribeDirectoriesOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDescribeDirectories == nil {
		opDescribeDirectories = &aws.Operation{
			Name:       "DescribeDirectories",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// 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.
func (c *DirectoryService) DescribeDirectories(input *DescribeDirectoriesInput) (*DescribeDirectoriesOutput, error) {
	req, out := c.DescribeDirectoriesRequest(input)
	err := req.Send()
	return out, err
}

var opDescribeDirectories *aws.Operation

// DescribeSnapshotsRequest generates a request for the DescribeSnapshots operation.
func (c *DirectoryService) DescribeSnapshotsRequest(input *DescribeSnapshotsInput) (req *aws.Request, output *DescribeSnapshotsOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDescribeSnapshots == nil {
		opDescribeSnapshots = &aws.Operation{
			Name:       "DescribeSnapshots",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// 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.
func (c *DirectoryService) DescribeSnapshots(input *DescribeSnapshotsInput) (*DescribeSnapshotsOutput, error) {
	req, out := c.DescribeSnapshotsRequest(input)
	err := req.Send()
	return out, err
}

var opDescribeSnapshots *aws.Operation

// DisableRadiusRequest generates a request for the DisableRadius operation.
func (c *DirectoryService) DisableRadiusRequest(input *DisableRadiusInput) (req *aws.Request, output *DisableRadiusOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDisableRadius == nil {
		opDisableRadius = &aws.Operation{
			Name:       "DisableRadius",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Disables multi-factor authentication (MFA) with Remote Authentication Dial
// In User Service (RADIUS) for an AD Connector directory.
func (c *DirectoryService) DisableRadius(input *DisableRadiusInput) (*DisableRadiusOutput, error) {
	req, out := c.DisableRadiusRequest(input)
	err := req.Send()
	return out, err
}

var opDisableRadius *aws.Operation

// DisableSSORequest generates a request for the DisableSSO operation.
func (c *DirectoryService) DisableSSORequest(input *DisableSSOInput) (req *aws.Request, output *DisableSSOOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDisableSSO == nil {
		opDisableSSO = &aws.Operation{
			Name:       "DisableSso",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &DisableSSOInput{}
	}

	req = c.newRequest(opDisableSSO, input, output)
	output = &DisableSSOOutput{}
	req.Data = output
	return
}

// Disables single-sign on for a directory.
func (c *DirectoryService) DisableSSO(input *DisableSSOInput) (*DisableSSOOutput, error) {
	req, out := c.DisableSSORequest(input)
	err := req.Send()
	return out, err
}

var opDisableSSO *aws.Operation

// EnableRadiusRequest generates a request for the EnableRadius operation.
func (c *DirectoryService) EnableRadiusRequest(input *EnableRadiusInput) (req *aws.Request, output *EnableRadiusOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opEnableRadius == nil {
		opEnableRadius = &aws.Operation{
			Name:       "EnableRadius",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Enables multi-factor authentication (MFA) with Remote Authentication Dial
// In User Service (RADIUS) for an AD Connector directory.
func (c *DirectoryService) EnableRadius(input *EnableRadiusInput) (*EnableRadiusOutput, error) {
	req, out := c.EnableRadiusRequest(input)
	err := req.Send()
	return out, err
}

var opEnableRadius *aws.Operation

// EnableSSORequest generates a request for the EnableSSO operation.
func (c *DirectoryService) EnableSSORequest(input *EnableSSOInput) (req *aws.Request, output *EnableSSOOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opEnableSSO == nil {
		opEnableSSO = &aws.Operation{
			Name:       "EnableSso",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &EnableSSOInput{}
	}

	req = c.newRequest(opEnableSSO, input, output)
	output = &EnableSSOOutput{}
	req.Data = output
	return
}

// Enables single-sign on for a directory.
func (c *DirectoryService) EnableSSO(input *EnableSSOInput) (*EnableSSOOutput, error) {
	req, out := c.EnableSSORequest(input)
	err := req.Send()
	return out, err
}

var opEnableSSO *aws.Operation

// GetDirectoryLimitsRequest generates a request for the GetDirectoryLimits operation.
func (c *DirectoryService) GetDirectoryLimitsRequest(input *GetDirectoryLimitsInput) (req *aws.Request, output *GetDirectoryLimitsOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opGetDirectoryLimits == nil {
		opGetDirectoryLimits = &aws.Operation{
			Name:       "GetDirectoryLimits",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Obtains directory limit information for the current region.
func (c *DirectoryService) GetDirectoryLimits(input *GetDirectoryLimitsInput) (*GetDirectoryLimitsOutput, error) {
	req, out := c.GetDirectoryLimitsRequest(input)
	err := req.Send()
	return out, err
}

var opGetDirectoryLimits *aws.Operation

// GetSnapshotLimitsRequest generates a request for the GetSnapshotLimits operation.
func (c *DirectoryService) GetSnapshotLimitsRequest(input *GetSnapshotLimitsInput) (req *aws.Request, output *GetSnapshotLimitsOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opGetSnapshotLimits == nil {
		opGetSnapshotLimits = &aws.Operation{
			Name:       "GetSnapshotLimits",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Obtains the manual snapshot limits for a directory.
func (c *DirectoryService) GetSnapshotLimits(input *GetSnapshotLimitsInput) (*GetSnapshotLimitsOutput, error) {
	req, out := c.GetSnapshotLimitsRequest(input)
	err := req.Send()
	return out, err
}

var opGetSnapshotLimits *aws.Operation

// RestoreFromSnapshotRequest generates a request for the RestoreFromSnapshot operation.
func (c *DirectoryService) RestoreFromSnapshotRequest(input *RestoreFromSnapshotInput) (req *aws.Request, output *RestoreFromSnapshotOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opRestoreFromSnapshot == nil {
		opRestoreFromSnapshot = &aws.Operation{
			Name:       "RestoreFromSnapshot",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// 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.
func (c *DirectoryService) RestoreFromSnapshot(input *RestoreFromSnapshotInput) (*RestoreFromSnapshotOutput, error) {
	req, out := c.RestoreFromSnapshotRequest(input)
	err := req.Send()
	return out, err
}

var opRestoreFromSnapshot *aws.Operation

// UpdateRadiusRequest generates a request for the UpdateRadius operation.
func (c *DirectoryService) UpdateRadiusRequest(input *UpdateRadiusInput) (req *aws.Request, output *UpdateRadiusOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opUpdateRadius == nil {
		opUpdateRadius = &aws.Operation{
			Name:       "UpdateRadius",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

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

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

// Updates the Remote Authentication Dial In User Service (RADIUS) server information
// for an AD Connector directory.
func (c *DirectoryService) UpdateRadius(input *UpdateRadiusInput) (*UpdateRadiusOutput, error) {
	req, out := c.UpdateRadiusRequest(input)
	err := req.Send()
	return out, err
}

var opUpdateRadius *aws.Operation

// Represents a named directory attribute.
type Attribute struct {
	// The name of the attribute.
	Name *string `type:"string"`

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

	metadataAttribute `json:"-" xml:"-"`
}

type metadataAttribute struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information about a computer account in a directory.
type Computer struct {
	// An array of Attribute objects that contain the LDAP attributes that belong
	// to the computer account.
	ComputerAttributes []*Attribute `type:"list"`

	// The identifier of the computer.
	ComputerID *string `locationName:"ComputerId" type:"string"`

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

	metadataComputer `json:"-" xml:"-"`
}

type metadataComputer struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the ConnectDirectory operation.
type ConnectDirectoryInput struct {
	// A DirectoryConnectSettings object that contains additional information for
	// the operation.
	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 *string `type:"string" required:"true"`

	// The password for the on-premises user account.
	Password *string `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 *string `type:"string" required:"true"`

	metadataConnectDirectoryInput `json:"-" xml:"-"`
}

type metadataConnectDirectoryInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the ConnectDirectory operation.
type ConnectDirectoryOutput struct {
	// The identifier of the new directory.
	DirectoryID *string `locationName:"DirectoryId" type:"string"`

	metadataConnectDirectoryOutput `json:"-" xml:"-"`
}

type metadataConnectDirectoryOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the CreateAlias operation.
type CreateAliasInput struct {
	// The requested alias.
	//
	// The alias must be unique amongst all aliases in AWS. This operation will
	// throw an EntityAlreadyExistsException if this alias already exists.
	Alias *string `type:"string" required:"true"`

	// The identifier of the directory to create the alias for.
	DirectoryID *string `locationName:"DirectoryId" type:"string" required:"true"`

	metadataCreateAliasInput `json:"-" xml:"-"`
}

type metadataCreateAliasInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the CreateAlias operation.
type CreateAliasOutput struct {
	// The alias for the directory.
	Alias *string `type:"string"`

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

	metadataCreateAliasOutput `json:"-" xml:"-"`
}

type metadataCreateAliasOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the CreateComputer operation.
type CreateComputerInput struct {
	// 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 *string `type:"string" required:"true"`

	// The identifier of the directory to create the computer account in.
	DirectoryID *string `locationName:"DirectoryId" type:"string" required:"true"`

	// The fully-qualified distinguished name of the organizational unit to place
	// the computer account in.
	OrganizationalUnitDistinguishedName *string `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 *string `type:"string" required:"true"`

	metadataCreateComputerInput `json:"-" xml:"-"`
}

type metadataCreateComputerInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results for the CreateComputer operation.
type CreateComputerOutput struct {
	// A Computer object the represents the computer account.
	Computer *Computer `type:"structure"`

	metadataCreateComputerOutput `json:"-" xml:"-"`
}

type metadataCreateComputerOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the CreateDirectory operation.
type CreateDirectoryInput struct {
	// A textual description for the directory.
	Description *string `type:"string"`

	// The fully qualified name for the directory, such as corp.example.com.
	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 *string `type:"string" required:"true"`

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

	// The size of the directory.
	Size *string `type:"string" required:"true"`

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

	metadataCreateDirectoryInput `json:"-" xml:"-"`
}

type metadataCreateDirectoryInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the CreateDirectory operation.
type CreateDirectoryOutput struct {
	// The identifier of the directory that was created.
	DirectoryID *string `locationName:"DirectoryId" type:"string"`

	metadataCreateDirectoryOutput `json:"-" xml:"-"`
}

type metadataCreateDirectoryOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the CreateSnapshot operation.
type CreateSnapshotInput struct {
	// The identifier of the directory to take a snapshot of.
	DirectoryID *string `locationName:"DirectoryId" type:"string" required:"true"`

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

	metadataCreateSnapshotInput `json:"-" xml:"-"`
}

type metadataCreateSnapshotInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the CreateSnapshot operation.
type CreateSnapshotOutput struct {
	// The identifier of the snapshot that was created.
	SnapshotID *string `locationName:"SnapshotId" type:"string"`

	metadataCreateSnapshotOutput `json:"-" xml:"-"`
}

type metadataCreateSnapshotOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the DeleteDirectory operation.
type DeleteDirectoryInput struct {
	// The identifier of the directory to delete.
	DirectoryID *string `locationName:"DirectoryId" type:"string" required:"true"`

	metadataDeleteDirectoryInput `json:"-" xml:"-"`
}

type metadataDeleteDirectoryInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the DeleteDirectory operation.
type DeleteDirectoryOutput struct {
	// The directory identifier.
	DirectoryID *string `locationName:"DirectoryId" type:"string"`

	metadataDeleteDirectoryOutput `json:"-" xml:"-"`
}

type metadataDeleteDirectoryOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the DeleteSnapshot operation.
type DeleteSnapshotInput struct {
	// The identifier of the directory snapshot to be deleted.
	SnapshotID *string `locationName:"SnapshotId" type:"string" required:"true"`

	metadataDeleteSnapshotInput `json:"-" xml:"-"`
}

type metadataDeleteSnapshotInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the DeleteSnapshot operation.
type DeleteSnapshotOutput struct {
	// The identifier of the directory snapshot that was deleted.
	SnapshotID *string `locationName:"SnapshotId" type:"string"`

	metadataDeleteSnapshotOutput `json:"-" xml:"-"`
}

type metadataDeleteSnapshotOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the DescribeDirectories operation.
type DescribeDirectoriesInput struct {
	// A list of identifiers of the directories to obtain the information for. 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 `locationName:"DirectoryIds" 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"`

	metadataDescribeDirectoriesInput `json:"-" xml:"-"`
}

type metadataDescribeDirectoriesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the DescribeDirectories operation.
type DescribeDirectoriesOutput struct {
	// 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"`

	metadataDescribeDirectoriesOutput `json:"-" xml:"-"`
}

type metadataDescribeDirectoriesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the DescribeSnapshots operation.
type DescribeSnapshotsInput struct {
	// The identifier of the directory to retrieve snapshot information for.
	DirectoryID *string `locationName:"DirectoryId" 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 `locationName:"SnapshotIds" type:"list"`

	metadataDescribeSnapshotsInput `json:"-" xml:"-"`
}

type metadataDescribeSnapshotsInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the DescribeSnapshots operation.
type DescribeSnapshotsOutput struct {
	// 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"`

	metadataDescribeSnapshotsOutput `json:"-" xml:"-"`
}

type metadataDescribeSnapshotsOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information for the ConnectDirectory operation when an AD Connector
// directory is being created.
type DirectoryConnectSettings struct {
	// A list of one or more IP addresses of DNS servers or domain controllers in
	// the on-premises directory.
	CustomerDNSIPs []*string `locationName:"CustomerDnsIps" 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 *string `type:"string" required:"true"`

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

	// The identifier of the VPC that the AD Connector is created in.
	VPCID *string `locationName:"VpcId" type:"string" required:"true"`

	metadataDirectoryConnectSettings `json:"-" xml:"-"`
}

type metadataDirectoryConnectSettings struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information about an AD Connector directory.
type DirectoryConnectSettingsDescription struct {
	// 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 `locationName:"ConnectIps" type:"list"`

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

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

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

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

	metadataDirectoryConnectSettingsDescription `json:"-" xml:"-"`
}

type metadataDirectoryConnectSettingsDescription struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information about an AWS Directory Service directory.
type DirectoryDescription struct {
	// The access URL for the directory, such as http://<alias>.awsapps.com.
	AccessURL *string `locationName:"AccessUrl" type:"string"`

	// The alias for the directory.
	Alias *string `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 IP addresses of the DNS servers for the directory. For a Simple AD directory,
	// these are the IP addresses of the Simple 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 that the AD Connector is connected
	// to.
	DNSIPAddrs []*string `locationName:"DnsIpAddrs" type:"list"`

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

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

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

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

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

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

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

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

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

	metadataDirectoryDescription `json:"-" xml:"-"`
}

type metadataDirectoryDescription struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains directory limit information for a region.
type DirectoryLimits struct {
	// 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 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"`

	metadataDirectoryLimits `json:"-" xml:"-"`
}

type metadataDirectoryLimits struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information for the CreateDirectory operation when a Simple AD directory
// is being created.
type DirectoryVPCSettings struct {
	// 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 []*string `locationName:"SubnetIds" type:"list" required:"true"`

	// The identifier of the VPC to create the Simple AD directory in.
	VPCID *string `locationName:"VpcId" type:"string" required:"true"`

	metadataDirectoryVPCSettings `json:"-" xml:"-"`
}

type metadataDirectoryVPCSettings struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information about a Simple AD directory.
type DirectoryVPCSettingsDescription struct {
	// The list of Availability Zones that the directory is in.
	AvailabilityZones []*string `type:"list"`

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

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

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

	metadataDirectoryVPCSettingsDescription `json:"-" xml:"-"`
}

type metadataDirectoryVPCSettingsDescription struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the DisableRadius operation.
type DisableRadiusInput struct {
	// The identifier of the directory to disable MFA for.
	DirectoryID *string `locationName:"DirectoryId" type:"string" required:"true"`

	metadataDisableRadiusInput `json:"-" xml:"-"`
}

type metadataDisableRadiusInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the DisableRadius operation.
type DisableRadiusOutput struct {
	metadataDisableRadiusOutput `json:"-" xml:"-"`
}

type metadataDisableRadiusOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the DisableSso operation.
type DisableSSOInput struct {
	// The identifier of the directory to disable single-sign on for.
	DirectoryID *string `locationName:"DirectoryId" 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. See the UserName parameter for
	// more information.
	Password *string `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 principle name.
	//
	// If the AD Connector service account does not have privileges to remove a
	// service principle 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 `type:"string"`

	metadataDisableSSOInput `json:"-" xml:"-"`
}

type metadataDisableSSOInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the DisableSso operation.
type DisableSSOOutput struct {
	metadataDisableSSOOutput `json:"-" xml:"-"`
}

type metadataDisableSSOOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the EnableRadius operation.
type EnableRadiusInput struct {
	// The identifier of the directory to enable MFA for.
	DirectoryID *string `locationName:"DirectoryId" type:"string" required:"true"`

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

	metadataEnableRadiusInput `json:"-" xml:"-"`
}

type metadataEnableRadiusInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the EnableRadius operation.
type EnableRadiusOutput struct {
	metadataEnableRadiusOutput `json:"-" xml:"-"`
}

type metadataEnableRadiusOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the EnableSso operation.
type EnableSSOInput struct {
	// The identifier of the directory to enable single-sign on for.
	DirectoryID *string `locationName:"DirectoryId" 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. See the UserName parameter for
	// more information.
	Password *string `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 principle name.
	//
	// If the AD Connector service account does not have privileges to add a service
	// principle 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 `type:"string"`

	metadataEnableSSOInput `json:"-" xml:"-"`
}

type metadataEnableSSOInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the EnableSso operation.
type EnableSSOOutput struct {
	metadataEnableSSOOutput `json:"-" xml:"-"`
}

type metadataEnableSSOOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the GetDirectoryLimits operation.
type GetDirectoryLimitsInput struct {
	metadataGetDirectoryLimitsInput `json:"-" xml:"-"`
}

type metadataGetDirectoryLimitsInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the GetDirectoryLimits operation.
type GetDirectoryLimitsOutput struct {
	// A DirectoryLimits object that contains the directory limits for the current
	// region.
	DirectoryLimits *DirectoryLimits `type:"structure"`

	metadataGetDirectoryLimitsOutput `json:"-" xml:"-"`
}

type metadataGetDirectoryLimitsOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the GetSnapshotLimits operation.
type GetSnapshotLimitsInput struct {
	// Contains the identifier of the directory to obtain the limits for.
	DirectoryID *string `locationName:"DirectoryId" type:"string" required:"true"`

	metadataGetSnapshotLimitsInput `json:"-" xml:"-"`
}

type metadataGetSnapshotLimitsInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the GetSnapshotLimits operation.
type GetSnapshotLimitsOutput struct {
	// A SnapshotLimits object that contains the manual snapshot limits for the
	// specified directory.
	SnapshotLimits *SnapshotLimits `type:"structure"`

	metadataGetSnapshotLimitsOutput `json:"-" xml:"-"`
}

type metadataGetSnapshotLimitsOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains information about a Remote Authentication Dial In User Service (RADIUS)
// server.
type RadiusSettings struct {
	// The protocol specified for your RADIUS endpoints.
	AuthenticationProtocol *string `type:"string"`

	// Not currently used.
	DisplayLabel *string `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 `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 `type:"integer"`

	// The shared secret code that was specified when your RADIUS endpoints were
	// created.
	SharedSecret *string `type:"string"`

	// Not currently used.
	UseSameUsername *bool `type:"boolean"`

	metadataRadiusSettings `json:"-" xml:"-"`
}

type metadataRadiusSettings struct {
	SDKShapeTraits bool `type:"structure"`
}

// An object representing the inputs for the RestoreFromSnapshot operation.
type RestoreFromSnapshotInput struct {
	// The identifier of the snapshot to restore from.
	SnapshotID *string `locationName:"SnapshotId" type:"string" required:"true"`

	metadataRestoreFromSnapshotInput `json:"-" xml:"-"`
}

type metadataRestoreFromSnapshotInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the RestoreFromSnapshot operation.
type RestoreFromSnapshotOutput struct {
	metadataRestoreFromSnapshotOutput `json:"-" xml:"-"`
}

type metadataRestoreFromSnapshotOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Describes a directory snapshot.
type Snapshot struct {
	// The directory identifier.
	DirectoryID *string `locationName:"DirectoryId" type:"string"`

	// The descriptive name of the snapshot.
	Name *string `type:"string"`

	// The snapshot identifier.
	SnapshotID *string `locationName:"SnapshotId" 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"`

	// The snapshot type.
	Type *string `type:"string"`

	metadataSnapshot `json:"-" xml:"-"`
}

type metadataSnapshot struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains manual snapshot limit information for a directory.
type SnapshotLimits struct {
	// 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"`

	metadataSnapshotLimits `json:"-" xml:"-"`
}

type metadataSnapshotLimits struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the inputs for the UpdateRadius operation.
type UpdateRadiusInput struct {
	// The identifier of the directory to update the RADIUS server information for.
	DirectoryID *string `locationName:"DirectoryId" type:"string" required:"true"`

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

	metadataUpdateRadiusInput `json:"-" xml:"-"`
}

type metadataUpdateRadiusInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the results of the UpdateRadius operation.
type UpdateRadiusOutput struct {
	metadataUpdateRadiusOutput `json:"-" xml:"-"`
}

type metadataUpdateRadiusOutput struct {
	SDKShapeTraits bool `type:"structure"`
}