Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string

	RequestId *string
}

    Client authentication is not available in this region at this time.

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

    func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type Attribute

    type Attribute struct {
    
    	// The name of the attribute.
    	Name *string
    
    	// The value of the attribute.
    	Value *string
    }

      Represents a named directory attribute.

      type AuthenticationFailedException

      type AuthenticationFailedException struct {
      	Message *string
      
      	RequestId *string
      }

        An authentication error occurred.

        func (*AuthenticationFailedException) Error

        func (*AuthenticationFailedException) ErrorCode

        func (e *AuthenticationFailedException) ErrorCode() string

        func (*AuthenticationFailedException) ErrorFault

        func (*AuthenticationFailedException) ErrorMessage

        func (e *AuthenticationFailedException) ErrorMessage() string

        type Certificate

        type Certificate struct {
        
        	// The identifier of the certificate.
        	CertificateId *string
        
        	// A ClientCertAuthSettings object that contains client certificate authentication
        	// settings.
        	ClientCertAuthSettings *ClientCertAuthSettings
        
        	// The common name for the certificate.
        	CommonName *string
        
        	// The date and time when the certificate will expire.
        	ExpiryDateTime *time.Time
        
        	// The date and time that the certificate was registered.
        	RegisteredDateTime *time.Time
        
        	// The state of the certificate.
        	State CertificateState
        
        	// Describes a state change for the certificate.
        	StateReason *string
        
        	// The function that the registered certificate performs. Valid values include
        	// ClientLDAPS or ClientCertAuth. The default value is ClientLDAPS.
        	Type CertificateType
        }

          Information about the certificate.

          type CertificateAlreadyExistsException

          type CertificateAlreadyExistsException struct {
          	Message *string
          
          	RequestId *string
          }

            The certificate has already been registered into the system.

            func (*CertificateAlreadyExistsException) Error

            func (*CertificateAlreadyExistsException) ErrorCode

            func (*CertificateAlreadyExistsException) ErrorFault

            func (*CertificateAlreadyExistsException) ErrorMessage

            func (e *CertificateAlreadyExistsException) ErrorMessage() string

            type CertificateDoesNotExistException

            type CertificateDoesNotExistException struct {
            	Message *string
            
            	RequestId *string
            }

              The certificate is not present in the system for describe or deregister activities.

              func (*CertificateDoesNotExistException) Error

              func (*CertificateDoesNotExistException) ErrorCode

              func (*CertificateDoesNotExistException) ErrorFault

              func (*CertificateDoesNotExistException) ErrorMessage

              func (e *CertificateDoesNotExistException) ErrorMessage() string

              type CertificateInUseException

              type CertificateInUseException struct {
              	Message *string
              
              	RequestId *string
              }

                The certificate is being used for the LDAP security connection and cannot be removed without disabling LDAP security.

                func (*CertificateInUseException) Error

                func (e *CertificateInUseException) Error() string

                func (*CertificateInUseException) ErrorCode

                func (e *CertificateInUseException) ErrorCode() string

                func (*CertificateInUseException) ErrorFault

                func (*CertificateInUseException) ErrorMessage

                func (e *CertificateInUseException) ErrorMessage() string

                type CertificateInfo

                type CertificateInfo struct {
                
                	// The identifier of the certificate.
                	CertificateId *string
                
                	// The common name for the certificate.
                	CommonName *string
                
                	// The date and time when the certificate will expire.
                	ExpiryDateTime *time.Time
                
                	// The state of the certificate.
                	State CertificateState
                
                	// The function that the registered certificate performs. Valid values include
                	// ClientLDAPS or ClientCertAuth. The default value is ClientLDAPS.
                	Type CertificateType
                }

                  Contains general information about a certificate.

                  type CertificateLimitExceededException

                  type CertificateLimitExceededException struct {
                  	Message *string
                  
                  	RequestId *string
                  }

                    The certificate could not be added because the certificate limit has been reached.

                    func (*CertificateLimitExceededException) Error

                    func (*CertificateLimitExceededException) ErrorCode

                    func (*CertificateLimitExceededException) ErrorFault

                    func (*CertificateLimitExceededException) ErrorMessage

                    func (e *CertificateLimitExceededException) ErrorMessage() string

                    type CertificateState

                    type CertificateState string
                    const (
                    	CertificateStateRegistering      CertificateState = "Registering"
                    	CertificateStateRegistered       CertificateState = "Registered"
                    	CertificateStateRegisterFailed   CertificateState = "RegisterFailed"
                    	CertificateStateDeregistering    CertificateState = "Deregistering"
                    	CertificateStateDeregistered     CertificateState = "Deregistered"
                    	CertificateStateDeregisterFailed CertificateState = "DeregisterFailed"
                    )

                      Enum values for CertificateState

                      func (CertificateState) Values

                        Values returns all known values for CertificateState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                        type CertificateType

                        type CertificateType string
                        const (
                        	CertificateTypeClientCertAuth CertificateType = "ClientCertAuth"
                        	CertificateTypeClientLdaps    CertificateType = "ClientLDAPS"
                        )

                          Enum values for CertificateType

                          func (CertificateType) Values

                          func (CertificateType) Values() []CertificateType

                            Values returns all known values for CertificateType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                            type ClientAuthenticationType

                            type ClientAuthenticationType string
                            const (
                            	ClientAuthenticationTypeSmartCard ClientAuthenticationType = "SmartCard"
                            )

                              Enum values for ClientAuthenticationType

                              func (ClientAuthenticationType) Values

                                Values returns all known values for ClientAuthenticationType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                type ClientCertAuthSettings

                                type ClientCertAuthSettings struct {
                                
                                	// Specifies the URL of the default OCSP server used to check for revocation
                                	// status. A secondary value to any OCSP address found in the AIA extension of the
                                	// user certificate.
                                	OCSPUrl *string
                                }

                                  Contains information about the client certificate authentication settings for the RegisterCertificate and DescribeCertificate operations.

                                  type ClientException

                                  type ClientException struct {
                                  	Message *string
                                  
                                  	RequestId *string
                                  }

                                    A client exception has occurred.

                                    func (*ClientException) Error

                                    func (e *ClientException) Error() string

                                    func (*ClientException) ErrorCode

                                    func (e *ClientException) ErrorCode() string

                                    func (*ClientException) ErrorFault

                                    func (e *ClientException) ErrorFault() smithy.ErrorFault

                                    func (*ClientException) ErrorMessage

                                    func (e *ClientException) ErrorMessage() string

                                    type Computer

                                    type Computer struct {
                                    
                                    	// An array of Attribute objects containing the LDAP attributes that belong to the
                                    	// computer account.
                                    	ComputerAttributes []Attribute
                                    
                                    	// The identifier of the computer.
                                    	ComputerId *string
                                    
                                    	// The computer name.
                                    	ComputerName *string
                                    }

                                      Contains information about a computer account in a directory.

                                      type ConditionalForwarder

                                      type ConditionalForwarder struct {
                                      
                                      	// 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
                                      
                                      	// The fully qualified domain name (FQDN) of the remote domains pointed to by the
                                      	// conditional forwarder.
                                      	RemoteDomainName *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 ReplicationScope
                                      }

                                        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 DirectoryAlreadyInRegionException

                                        type DirectoryAlreadyInRegionException struct {
                                        	Message *string
                                        
                                        	RequestId *string
                                        }

                                          The Region you specified is the same Region where the AWS Managed Microsoft AD directory was created. Specify a different Region and try again.

                                          func (*DirectoryAlreadyInRegionException) Error

                                          func (*DirectoryAlreadyInRegionException) ErrorCode

                                          func (*DirectoryAlreadyInRegionException) ErrorFault

                                          func (*DirectoryAlreadyInRegionException) ErrorMessage

                                          func (e *DirectoryAlreadyInRegionException) ErrorMessage() string

                                          type DirectoryAlreadySharedException

                                          type DirectoryAlreadySharedException struct {
                                          	Message *string
                                          
                                          	RequestId *string
                                          }

                                            The specified directory has already been shared with this AWS account.

                                            func (*DirectoryAlreadySharedException) Error

                                            func (*DirectoryAlreadySharedException) ErrorCode

                                            func (e *DirectoryAlreadySharedException) ErrorCode() string

                                            func (*DirectoryAlreadySharedException) ErrorFault

                                            func (*DirectoryAlreadySharedException) ErrorMessage

                                            func (e *DirectoryAlreadySharedException) ErrorMessage() string

                                            type DirectoryConnectSettings

                                            type DirectoryConnectSettings struct {
                                            
                                            	// A list of one or more IP addresses of DNS servers or domain controllers in the
                                            	// on-premises directory.
                                            	//
                                            	// This member is required.
                                            	CustomerDnsIps []string
                                            
                                            	// The user name of an account in the on-premises directory that is used to connect
                                            	// to the directory. This account must have the following permissions:
                                            	//
                                            	// * Read
                                            	// users and groups
                                            	//
                                            	// * Create computer objects
                                            	//
                                            	// * Join computers to the domain
                                            	//
                                            	// This member is required.
                                            	CustomerUserName *string
                                            
                                            	// A list of subnet identifiers in the VPC in which the AD Connector is created.
                                            	//
                                            	// This member is required.
                                            	SubnetIds []string
                                            
                                            	// The identifier of the VPC in which the AD Connector is created.
                                            	//
                                            	// This member is required.
                                            	VpcId *string
                                            }

                                              Contains information for the ConnectDirectory operation when an AD Connector directory is being created.

                                              type DirectoryConnectSettingsDescription

                                              type DirectoryConnectSettingsDescription struct {
                                              
                                              	// A list of the Availability Zones that the directory is in.
                                              	AvailabilityZones []string
                                              
                                              	// The IP addresses of the AD Connector servers.
                                              	ConnectIps []string
                                              
                                              	// The user name of the service account in the on-premises directory.
                                              	CustomerUserName *string
                                              
                                              	// The security group identifier for the AD Connector directory.
                                              	SecurityGroupId *string
                                              
                                              	// A list of subnet identifiers in the VPC that the AD Connector is in.
                                              	SubnetIds []string
                                              
                                              	// The identifier of the VPC that the AD Connector is in.
                                              	VpcId *string
                                              }

                                                Contains information about an AD Connector directory.

                                                type DirectoryDescription

                                                type DirectoryDescription struct {
                                                
                                                	// The access URL for the directory, such as http://.awsapps.com. If no alias has
                                                	// been created for the directory,  is the directory identifier, such as
                                                	// d-XXXXXXXXXX.
                                                	AccessUrl *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
                                                
                                                	// 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
                                                
                                                	// The description for the directory.
                                                	Description *string
                                                
                                                	// The desired number of domain controllers in the directory if the directory is
                                                	// Microsoft AD.
                                                	DesiredNumberOfDomainControllers int32
                                                
                                                	// The directory identifier.
                                                	DirectoryId *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
                                                
                                                	// The edition associated with this directory.
                                                	Edition DirectoryEdition
                                                
                                                	// Specifies when the directory was created.
                                                	LaunchTime *time.Time
                                                
                                                	// The fully qualified name of the directory.
                                                	Name *string
                                                
                                                	// Describes the AWS Managed Microsoft AD directory in the directory owner account.
                                                	OwnerDirectoryDescription *OwnerDirectoryDescription
                                                
                                                	// A RadiusSettings object that contains information about the RADIUS server
                                                	// configured for this directory.
                                                	RadiusSettings *RadiusSettings
                                                
                                                	// The status of the RADIUS MFA server connection.
                                                	RadiusStatus RadiusStatus
                                                
                                                	// Lists the Regions where the directory has replicated.
                                                	RegionsInfo *RegionsInfo
                                                
                                                	// The method used when sharing a directory to determine whether the directory
                                                	// should be shared within your AWS organization (ORGANIZATIONS) or with any AWS
                                                	// account by sending a shared directory request (HANDSHAKE).
                                                	ShareMethod ShareMethod
                                                
                                                	// A directory share request that is sent by the directory owner to the directory
                                                	// consumer. The request includes a typed message to help the directory consumer
                                                	// administrator determine whether to approve or reject the share invitation.
                                                	ShareNotes *string
                                                
                                                	// Current directory status of the shared AWS Managed Microsoft AD directory.
                                                	ShareStatus ShareStatus
                                                
                                                	// The short name of the directory.
                                                	ShortName *string
                                                
                                                	// The directory size.
                                                	Size DirectorySize
                                                
                                                	// Indicates if single sign-on is enabled for the directory. For more information,
                                                	// see EnableSso and DisableSso.
                                                	SsoEnabled bool
                                                
                                                	// The current stage of the directory.
                                                	Stage DirectoryStage
                                                
                                                	// The date and time that the stage was last updated.
                                                	StageLastUpdatedDateTime *time.Time
                                                
                                                	// Additional information about the directory stage.
                                                	StageReason *string
                                                
                                                	// The directory size.
                                                	Type 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
                                                }

                                                  Contains information about an AWS Directory Service directory.

                                                  type DirectoryDoesNotExistException

                                                  type DirectoryDoesNotExistException struct {
                                                  	Message *string
                                                  
                                                  	RequestId *string
                                                  }

                                                    The specified directory does not exist in the system.

                                                    func (*DirectoryDoesNotExistException) Error

                                                    func (*DirectoryDoesNotExistException) ErrorCode

                                                    func (e *DirectoryDoesNotExistException) ErrorCode() string

                                                    func (*DirectoryDoesNotExistException) ErrorFault

                                                    func (*DirectoryDoesNotExistException) ErrorMessage

                                                    func (e *DirectoryDoesNotExistException) ErrorMessage() string

                                                    type DirectoryEdition

                                                    type DirectoryEdition string
                                                    const (
                                                    	DirectoryEditionEnterprise DirectoryEdition = "Enterprise"
                                                    	DirectoryEditionStandard   DirectoryEdition = "Standard"
                                                    )

                                                      Enum values for DirectoryEdition

                                                      func (DirectoryEdition) Values

                                                        Values returns all known values for DirectoryEdition. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                        type DirectoryLimitExceededException

                                                        type DirectoryLimitExceededException struct {
                                                        	Message *string
                                                        
                                                        	RequestId *string
                                                        }

                                                          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.

                                                          func (*DirectoryLimitExceededException) Error

                                                          func (*DirectoryLimitExceededException) ErrorCode

                                                          func (e *DirectoryLimitExceededException) ErrorCode() string

                                                          func (*DirectoryLimitExceededException) ErrorFault

                                                          func (*DirectoryLimitExceededException) ErrorMessage

                                                          func (e *DirectoryLimitExceededException) ErrorMessage() string

                                                          type DirectoryLimits

                                                          type DirectoryLimits struct {
                                                          
                                                          	// The current number of cloud directories in the Region.
                                                          	CloudOnlyDirectoriesCurrentCount *int32
                                                          
                                                          	// The maximum number of cloud directories allowed in the Region.
                                                          	CloudOnlyDirectoriesLimit *int32
                                                          
                                                          	// Indicates if the cloud directory limit has been reached.
                                                          	CloudOnlyDirectoriesLimitReached bool
                                                          
                                                          	// The current number of AWS Managed Microsoft AD directories in the region.
                                                          	CloudOnlyMicrosoftADCurrentCount *int32
                                                          
                                                          	// The maximum number of AWS Managed Microsoft AD directories allowed in the
                                                          	// region.
                                                          	CloudOnlyMicrosoftADLimit *int32
                                                          
                                                          	// Indicates if the AWS Managed Microsoft AD directory limit has been reached.
                                                          	CloudOnlyMicrosoftADLimitReached bool
                                                          
                                                          	// The current number of connected directories in the Region.
                                                          	ConnectedDirectoriesCurrentCount *int32
                                                          
                                                          	// The maximum number of connected directories allowed in the Region.
                                                          	ConnectedDirectoriesLimit *int32
                                                          
                                                          	// Indicates if the connected directory limit has been reached.
                                                          	ConnectedDirectoriesLimitReached bool
                                                          }

                                                            Contains directory limit information for a Region.

                                                            type DirectoryNotSharedException

                                                            type DirectoryNotSharedException struct {
                                                            	Message *string
                                                            
                                                            	RequestId *string
                                                            }

                                                              The specified directory has not been shared with this AWS account.

                                                              func (*DirectoryNotSharedException) Error

                                                              func (*DirectoryNotSharedException) ErrorCode

                                                              func (e *DirectoryNotSharedException) ErrorCode() string

                                                              func (*DirectoryNotSharedException) ErrorFault

                                                              func (*DirectoryNotSharedException) ErrorMessage

                                                              func (e *DirectoryNotSharedException) ErrorMessage() string

                                                              type DirectorySize

                                                              type DirectorySize string
                                                              const (
                                                              	DirectorySizeSmall DirectorySize = "Small"
                                                              	DirectorySizeLarge DirectorySize = "Large"
                                                              )

                                                                Enum values for DirectorySize

                                                                func (DirectorySize) Values

                                                                func (DirectorySize) Values() []DirectorySize

                                                                  Values returns all known values for DirectorySize. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                  type DirectoryStage

                                                                  type DirectoryStage string
                                                                  const (
                                                                  	DirectoryStageRequested     DirectoryStage = "Requested"
                                                                  	DirectoryStageCreating      DirectoryStage = "Creating"
                                                                  	DirectoryStageCreated       DirectoryStage = "Created"
                                                                  	DirectoryStageActive        DirectoryStage = "Active"
                                                                  	DirectoryStageInoperable    DirectoryStage = "Inoperable"
                                                                  	DirectoryStageImpaired      DirectoryStage = "Impaired"
                                                                  	DirectoryStageRestoring     DirectoryStage = "Restoring"
                                                                  	DirectoryStageRestorefailed DirectoryStage = "RestoreFailed"
                                                                  	DirectoryStageDeleting      DirectoryStage = "Deleting"
                                                                  	DirectoryStageDeleted       DirectoryStage = "Deleted"
                                                                  	DirectoryStageFailed        DirectoryStage = "Failed"
                                                                  )

                                                                    Enum values for DirectoryStage

                                                                    func (DirectoryStage) Values

                                                                    func (DirectoryStage) Values() []DirectoryStage

                                                                      Values returns all known values for DirectoryStage. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                      type DirectoryType

                                                                      type DirectoryType string
                                                                      const (
                                                                      	DirectoryTypeSimpleAd          DirectoryType = "SimpleAD"
                                                                      	DirectoryTypeAdConnector       DirectoryType = "ADConnector"
                                                                      	DirectoryTypeMicrosoftAd       DirectoryType = "MicrosoftAD"
                                                                      	DirectoryTypeSharedMicrosoftAd DirectoryType = "SharedMicrosoftAD"
                                                                      )

                                                                        Enum values for DirectoryType

                                                                        func (DirectoryType) Values

                                                                        func (DirectoryType) Values() []DirectoryType

                                                                          Values returns all known values for DirectoryType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                          type DirectoryUnavailableException

                                                                          type DirectoryUnavailableException struct {
                                                                          	Message *string
                                                                          
                                                                          	RequestId *string
                                                                          }

                                                                            The specified directory is unavailable or could not be found.

                                                                            func (*DirectoryUnavailableException) Error

                                                                            func (*DirectoryUnavailableException) ErrorCode

                                                                            func (e *DirectoryUnavailableException) ErrorCode() string

                                                                            func (*DirectoryUnavailableException) ErrorFault

                                                                            func (*DirectoryUnavailableException) ErrorMessage

                                                                            func (e *DirectoryUnavailableException) ErrorMessage() string

                                                                            type DirectoryVpcSettings

                                                                            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.
                                                                            	//
                                                                            	// This member is required.
                                                                            	SubnetIds []string
                                                                            
                                                                            	// The identifier of the VPC in which to create the directory.
                                                                            	//
                                                                            	// This member is required.
                                                                            	VpcId *string
                                                                            }

                                                                              Contains VPC information for the CreateDirectory or CreateMicrosoftAD operation.

                                                                              type DirectoryVpcSettingsDescription

                                                                              type DirectoryVpcSettingsDescription struct {
                                                                              
                                                                              	// The list of Availability Zones that the directory is in.
                                                                              	AvailabilityZones []string
                                                                              
                                                                              	// The domain controller security group identifier for the directory.
                                                                              	SecurityGroupId *string
                                                                              
                                                                              	// The identifiers of the subnets for the directory servers.
                                                                              	SubnetIds []string
                                                                              
                                                                              	// The identifier of the VPC that the directory is in.
                                                                              	VpcId *string
                                                                              }

                                                                                Contains information about the directory.

                                                                                type DomainController

                                                                                type DomainController struct {
                                                                                
                                                                                	// The Availability Zone where the domain controller is located.
                                                                                	AvailabilityZone *string
                                                                                
                                                                                	// Identifier of the directory where the domain controller resides.
                                                                                	DirectoryId *string
                                                                                
                                                                                	// The IP address of the domain controller.
                                                                                	DnsIpAddr *string
                                                                                
                                                                                	// Identifies a specific domain controller in the directory.
                                                                                	DomainControllerId *string
                                                                                
                                                                                	// Specifies when the domain controller was created.
                                                                                	LaunchTime *time.Time
                                                                                
                                                                                	// The status of the domain controller.
                                                                                	Status DomainControllerStatus
                                                                                
                                                                                	// The date and time that the status was last updated.
                                                                                	StatusLastUpdatedDateTime *time.Time
                                                                                
                                                                                	// A description of the domain controller state.
                                                                                	StatusReason *string
                                                                                
                                                                                	// Identifier of the subnet in the VPC that contains the domain controller.
                                                                                	SubnetId *string
                                                                                
                                                                                	// The identifier of the VPC that contains the domain controller.
                                                                                	VpcId *string
                                                                                }

                                                                                  Contains information about the domain controllers for a specified directory.

                                                                                  type DomainControllerLimitExceededException

                                                                                  type DomainControllerLimitExceededException struct {
                                                                                  	Message *string
                                                                                  
                                                                                  	RequestId *string
                                                                                  }

                                                                                    The maximum allowed number of domain controllers per directory was exceeded. The default limit per directory is 20 domain controllers.

                                                                                    func (*DomainControllerLimitExceededException) Error

                                                                                    func (*DomainControllerLimitExceededException) ErrorCode

                                                                                    func (*DomainControllerLimitExceededException) ErrorFault

                                                                                    func (*DomainControllerLimitExceededException) ErrorMessage

                                                                                    type DomainControllerStatus

                                                                                    type DomainControllerStatus string
                                                                                    const (
                                                                                    	DomainControllerStatusCreating  DomainControllerStatus = "Creating"
                                                                                    	DomainControllerStatusActive    DomainControllerStatus = "Active"
                                                                                    	DomainControllerStatusImpaired  DomainControllerStatus = "Impaired"
                                                                                    	DomainControllerStatusRestoring DomainControllerStatus = "Restoring"
                                                                                    	DomainControllerStatusDeleting  DomainControllerStatus = "Deleting"
                                                                                    	DomainControllerStatusDeleted   DomainControllerStatus = "Deleted"
                                                                                    	DomainControllerStatusFailed    DomainControllerStatus = "Failed"
                                                                                    )

                                                                                      Enum values for DomainControllerStatus

                                                                                      func (DomainControllerStatus) Values

                                                                                        Values returns all known values for DomainControllerStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                        type EntityAlreadyExistsException

                                                                                        type EntityAlreadyExistsException struct {
                                                                                        	Message *string
                                                                                        
                                                                                        	RequestId *string
                                                                                        }

                                                                                          The specified entity already exists.

                                                                                          func (*EntityAlreadyExistsException) Error

                                                                                          func (*EntityAlreadyExistsException) ErrorCode

                                                                                          func (e *EntityAlreadyExistsException) ErrorCode() string

                                                                                          func (*EntityAlreadyExistsException) ErrorFault

                                                                                          func (*EntityAlreadyExistsException) ErrorMessage

                                                                                          func (e *EntityAlreadyExistsException) ErrorMessage() string

                                                                                          type EntityDoesNotExistException

                                                                                          type EntityDoesNotExistException struct {
                                                                                          	Message *string
                                                                                          
                                                                                          	RequestId *string
                                                                                          }

                                                                                            The specified entity could not be found.

                                                                                            func (*EntityDoesNotExistException) Error

                                                                                            func (*EntityDoesNotExistException) ErrorCode

                                                                                            func (e *EntityDoesNotExistException) ErrorCode() string

                                                                                            func (*EntityDoesNotExistException) ErrorFault

                                                                                            func (*EntityDoesNotExistException) ErrorMessage

                                                                                            func (e *EntityDoesNotExistException) ErrorMessage() string

                                                                                            type EventTopic

                                                                                            type EventTopic struct {
                                                                                            
                                                                                            	// The date and time of when you associated your directory with the SNS topic.
                                                                                            	CreatedDateTime *time.Time
                                                                                            
                                                                                            	// The Directory ID of an AWS Directory Service directory that will publish status
                                                                                            	// messages to an SNS topic.
                                                                                            	DirectoryId *string
                                                                                            
                                                                                            	// The topic registration status.
                                                                                            	Status TopicStatus
                                                                                            
                                                                                            	// The SNS topic ARN (Amazon Resource Name).
                                                                                            	TopicArn *string
                                                                                            
                                                                                            	// The name of an AWS SNS topic the receives status messages from the directory.
                                                                                            	TopicName *string
                                                                                            }

                                                                                              Information about SNS topic and AWS Directory Service directory associations.

                                                                                              type InsufficientPermissionsException

                                                                                              type InsufficientPermissionsException struct {
                                                                                              	Message *string
                                                                                              
                                                                                              	RequestId *string
                                                                                              }

                                                                                                The account does not have sufficient permission to perform the operation.

                                                                                                func (*InsufficientPermissionsException) Error

                                                                                                func (*InsufficientPermissionsException) ErrorCode

                                                                                                func (*InsufficientPermissionsException) ErrorFault

                                                                                                func (*InsufficientPermissionsException) ErrorMessage

                                                                                                func (e *InsufficientPermissionsException) ErrorMessage() string

                                                                                                type InvalidCertificateException

                                                                                                type InvalidCertificateException struct {
                                                                                                	Message *string
                                                                                                
                                                                                                	RequestId *string
                                                                                                }

                                                                                                  The certificate PEM that was provided has incorrect encoding.

                                                                                                  func (*InvalidCertificateException) Error

                                                                                                  func (*InvalidCertificateException) ErrorCode

                                                                                                  func (e *InvalidCertificateException) ErrorCode() string

                                                                                                  func (*InvalidCertificateException) ErrorFault

                                                                                                  func (*InvalidCertificateException) ErrorMessage

                                                                                                  func (e *InvalidCertificateException) ErrorMessage() string

                                                                                                  type InvalidClientAuthStatusException

                                                                                                  type InvalidClientAuthStatusException struct {
                                                                                                  	Message *string
                                                                                                  
                                                                                                  	RequestId *string
                                                                                                  }

                                                                                                    Client authentication is already enabled.

                                                                                                    func (*InvalidClientAuthStatusException) Error

                                                                                                    func (*InvalidClientAuthStatusException) ErrorCode

                                                                                                    func (*InvalidClientAuthStatusException) ErrorFault

                                                                                                    func (*InvalidClientAuthStatusException) ErrorMessage

                                                                                                    func (e *InvalidClientAuthStatusException) ErrorMessage() string

                                                                                                    type InvalidLDAPSStatusException

                                                                                                    type InvalidLDAPSStatusException struct {
                                                                                                    	Message *string
                                                                                                    
                                                                                                    	RequestId *string
                                                                                                    }

                                                                                                      The LDAP activities could not be performed because they are limited by the LDAPS status.

                                                                                                      func (*InvalidLDAPSStatusException) Error

                                                                                                      func (*InvalidLDAPSStatusException) ErrorCode

                                                                                                      func (e *InvalidLDAPSStatusException) ErrorCode() string

                                                                                                      func (*InvalidLDAPSStatusException) ErrorFault

                                                                                                      func (*InvalidLDAPSStatusException) ErrorMessage

                                                                                                      func (e *InvalidLDAPSStatusException) ErrorMessage() string

                                                                                                      type InvalidNextTokenException

                                                                                                      type InvalidNextTokenException struct {
                                                                                                      	Message *string
                                                                                                      
                                                                                                      	RequestId *string
                                                                                                      }

                                                                                                        The NextToken value is not valid.

                                                                                                        func (*InvalidNextTokenException) Error

                                                                                                        func (e *InvalidNextTokenException) Error() string

                                                                                                        func (*InvalidNextTokenException) ErrorCode

                                                                                                        func (e *InvalidNextTokenException) ErrorCode() string

                                                                                                        func (*InvalidNextTokenException) ErrorFault

                                                                                                        func (*InvalidNextTokenException) ErrorMessage

                                                                                                        func (e *InvalidNextTokenException) ErrorMessage() string

                                                                                                        type InvalidParameterException

                                                                                                        type InvalidParameterException struct {
                                                                                                        	Message *string
                                                                                                        
                                                                                                        	RequestId *string
                                                                                                        }

                                                                                                          One or more parameters are not valid.

                                                                                                          func (*InvalidParameterException) Error

                                                                                                          func (e *InvalidParameterException) Error() string

                                                                                                          func (*InvalidParameterException) ErrorCode

                                                                                                          func (e *InvalidParameterException) ErrorCode() string

                                                                                                          func (*InvalidParameterException) ErrorFault

                                                                                                          func (*InvalidParameterException) ErrorMessage

                                                                                                          func (e *InvalidParameterException) ErrorMessage() string

                                                                                                          type InvalidPasswordException

                                                                                                          type InvalidPasswordException struct {
                                                                                                          	Message *string
                                                                                                          
                                                                                                          	RequestId *string
                                                                                                          }

                                                                                                            The new password provided by the user does not meet the password complexity requirements defined in your directory.

                                                                                                            func (*InvalidPasswordException) Error

                                                                                                            func (e *InvalidPasswordException) Error() string

                                                                                                            func (*InvalidPasswordException) ErrorCode

                                                                                                            func (e *InvalidPasswordException) ErrorCode() string

                                                                                                            func (*InvalidPasswordException) ErrorFault

                                                                                                            func (e *InvalidPasswordException) ErrorFault() smithy.ErrorFault

                                                                                                            func (*InvalidPasswordException) ErrorMessage

                                                                                                            func (e *InvalidPasswordException) ErrorMessage() string

                                                                                                            type InvalidTargetException

                                                                                                            type InvalidTargetException struct {
                                                                                                            	Message *string
                                                                                                            
                                                                                                            	RequestId *string
                                                                                                            }

                                                                                                              The specified shared target is not valid.

                                                                                                              func (*InvalidTargetException) Error

                                                                                                              func (e *InvalidTargetException) Error() string

                                                                                                              func (*InvalidTargetException) ErrorCode

                                                                                                              func (e *InvalidTargetException) ErrorCode() string

                                                                                                              func (*InvalidTargetException) ErrorFault

                                                                                                              func (e *InvalidTargetException) ErrorFault() smithy.ErrorFault

                                                                                                              func (*InvalidTargetException) ErrorMessage

                                                                                                              func (e *InvalidTargetException) ErrorMessage() string

                                                                                                              type IpRoute

                                                                                                              type IpRoute struct {
                                                                                                              
                                                                                                              	// 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
                                                                                                              
                                                                                                              	// Description of the address block.
                                                                                                              	Description *string
                                                                                                              }

                                                                                                                IP address block. This is often the address block of the DNS server used for your on-premises domain.

                                                                                                                type IpRouteInfo

                                                                                                                type IpRouteInfo struct {
                                                                                                                
                                                                                                                	// The date and time the address block was added to the directory.
                                                                                                                	AddedDateTime *time.Time
                                                                                                                
                                                                                                                	// IP address block in the IpRoute.
                                                                                                                	CidrIp *string
                                                                                                                
                                                                                                                	// Description of the IpRouteInfo.
                                                                                                                	Description *string
                                                                                                                
                                                                                                                	// Identifier (ID) of the directory associated with the IP addresses.
                                                                                                                	DirectoryId *string
                                                                                                                
                                                                                                                	// The status of the IP address block.
                                                                                                                	IpRouteStatusMsg IpRouteStatusMsg
                                                                                                                
                                                                                                                	// The reason for the IpRouteStatusMsg.
                                                                                                                	IpRouteStatusReason *string
                                                                                                                }

                                                                                                                  Information about one or more IP address blocks.

                                                                                                                  type IpRouteLimitExceededException

                                                                                                                  type IpRouteLimitExceededException struct {
                                                                                                                  	Message *string
                                                                                                                  
                                                                                                                  	RequestId *string
                                                                                                                  }

                                                                                                                    The maximum allowed number of IP addresses was exceeded. The default limit is 100 IP address blocks.

                                                                                                                    func (*IpRouteLimitExceededException) Error

                                                                                                                    func (*IpRouteLimitExceededException) ErrorCode

                                                                                                                    func (e *IpRouteLimitExceededException) ErrorCode() string

                                                                                                                    func (*IpRouteLimitExceededException) ErrorFault

                                                                                                                    func (*IpRouteLimitExceededException) ErrorMessage

                                                                                                                    func (e *IpRouteLimitExceededException) ErrorMessage() string

                                                                                                                    type IpRouteStatusMsg

                                                                                                                    type IpRouteStatusMsg string
                                                                                                                    const (
                                                                                                                    	IpRouteStatusMsgAdding       IpRouteStatusMsg = "Adding"
                                                                                                                    	IpRouteStatusMsgAdded        IpRouteStatusMsg = "Added"
                                                                                                                    	IpRouteStatusMsgRemoving     IpRouteStatusMsg = "Removing"
                                                                                                                    	IpRouteStatusMsgRemoved      IpRouteStatusMsg = "Removed"
                                                                                                                    	IpRouteStatusMsgAddFailed    IpRouteStatusMsg = "AddFailed"
                                                                                                                    	IpRouteStatusMsgRemoveFailed IpRouteStatusMsg = "RemoveFailed"
                                                                                                                    )

                                                                                                                      Enum values for IpRouteStatusMsg

                                                                                                                      func (IpRouteStatusMsg) Values

                                                                                                                        Values returns all known values for IpRouteStatusMsg. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                        type LDAPSSettingInfo

                                                                                                                        type LDAPSSettingInfo struct {
                                                                                                                        
                                                                                                                        	// The state of the LDAPS settings.
                                                                                                                        	LDAPSStatus LDAPSStatus
                                                                                                                        
                                                                                                                        	// Describes a state change for LDAPS.
                                                                                                                        	LDAPSStatusReason *string
                                                                                                                        
                                                                                                                        	// The date and time when the LDAPS settings were last updated.
                                                                                                                        	LastUpdatedDateTime *time.Time
                                                                                                                        }

                                                                                                                          Contains general information about the LDAPS settings.

                                                                                                                          type LDAPSStatus

                                                                                                                          type LDAPSStatus string
                                                                                                                          const (
                                                                                                                          	LDAPSStatusEnabling     LDAPSStatus = "Enabling"
                                                                                                                          	LDAPSStatusEnabled      LDAPSStatus = "Enabled"
                                                                                                                          	LDAPSStatusEnableFailed LDAPSStatus = "EnableFailed"
                                                                                                                          	LDAPSStatusDisabled     LDAPSStatus = "Disabled"
                                                                                                                          )

                                                                                                                            Enum values for LDAPSStatus

                                                                                                                            func (LDAPSStatus) Values

                                                                                                                            func (LDAPSStatus) Values() []LDAPSStatus

                                                                                                                              Values returns all known values for LDAPSStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                              type LDAPSType

                                                                                                                              type LDAPSType string
                                                                                                                              const (
                                                                                                                              	LDAPSTypeClient LDAPSType = "Client"
                                                                                                                              )

                                                                                                                                Enum values for LDAPSType

                                                                                                                                func (LDAPSType) Values

                                                                                                                                func (LDAPSType) Values() []LDAPSType

                                                                                                                                  Values returns all known values for LDAPSType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                  type LogSubscription

                                                                                                                                  type LogSubscription struct {
                                                                                                                                  
                                                                                                                                  	// Identifier (ID) of the directory that you want to associate with the log
                                                                                                                                  	// subscription.
                                                                                                                                  	DirectoryId *string
                                                                                                                                  
                                                                                                                                  	// The name of the log group.
                                                                                                                                  	LogGroupName *string
                                                                                                                                  
                                                                                                                                  	// The date and time that the log subscription was created.
                                                                                                                                  	SubscriptionCreatedDateTime *time.Time
                                                                                                                                  }

                                                                                                                                    Represents a log subscription, which tracks real-time data from a chosen log group to a specified destination.

                                                                                                                                    type NoAvailableCertificateException

                                                                                                                                    type NoAvailableCertificateException struct {
                                                                                                                                    	Message *string
                                                                                                                                    
                                                                                                                                    	RequestId *string
                                                                                                                                    }

                                                                                                                                      Client authentication setup could not be completed because at least one valid certificate must be registered in the system.

                                                                                                                                      func (*NoAvailableCertificateException) Error

                                                                                                                                      func (*NoAvailableCertificateException) ErrorCode

                                                                                                                                      func (e *NoAvailableCertificateException) ErrorCode() string

                                                                                                                                      func (*NoAvailableCertificateException) ErrorFault

                                                                                                                                      func (*NoAvailableCertificateException) ErrorMessage

                                                                                                                                      func (e *NoAvailableCertificateException) ErrorMessage() string

                                                                                                                                      type OrganizationsException

                                                                                                                                      type OrganizationsException struct {
                                                                                                                                      	Message *string
                                                                                                                                      
                                                                                                                                      	RequestId *string
                                                                                                                                      }

                                                                                                                                        Exception encountered while trying to access your AWS organization.

                                                                                                                                        func (*OrganizationsException) Error

                                                                                                                                        func (e *OrganizationsException) Error() string

                                                                                                                                        func (*OrganizationsException) ErrorCode

                                                                                                                                        func (e *OrganizationsException) ErrorCode() string

                                                                                                                                        func (*OrganizationsException) ErrorFault

                                                                                                                                        func (e *OrganizationsException) ErrorFault() smithy.ErrorFault

                                                                                                                                        func (*OrganizationsException) ErrorMessage

                                                                                                                                        func (e *OrganizationsException) ErrorMessage() string

                                                                                                                                        type OwnerDirectoryDescription

                                                                                                                                        type OwnerDirectoryDescription struct {
                                                                                                                                        
                                                                                                                                        	// Identifier of the directory owner account.
                                                                                                                                        	AccountId *string
                                                                                                                                        
                                                                                                                                        	// Identifier of the AWS Managed Microsoft AD directory in the directory owner
                                                                                                                                        	// account.
                                                                                                                                        	DirectoryId *string
                                                                                                                                        
                                                                                                                                        	// IP address of the directory’s domain controllers.
                                                                                                                                        	DnsIpAddrs []string
                                                                                                                                        
                                                                                                                                        	// A RadiusSettings object that contains information about the RADIUS server.
                                                                                                                                        	RadiusSettings *RadiusSettings
                                                                                                                                        
                                                                                                                                        	// Information about the status of the RADIUS server.
                                                                                                                                        	RadiusStatus RadiusStatus
                                                                                                                                        
                                                                                                                                        	// Information about the VPC settings for the directory.
                                                                                                                                        	VpcSettings *DirectoryVpcSettingsDescription
                                                                                                                                        }

                                                                                                                                          Describes the directory owner account details that have been shared to the directory consumer account.

                                                                                                                                          type RadiusAuthenticationProtocol

                                                                                                                                          type RadiusAuthenticationProtocol string
                                                                                                                                          const (
                                                                                                                                          	RadiusAuthenticationProtocolPap      RadiusAuthenticationProtocol = "PAP"
                                                                                                                                          	RadiusAuthenticationProtocolChap     RadiusAuthenticationProtocol = "CHAP"
                                                                                                                                          	RadiusAuthenticationProtocolMschapv1 RadiusAuthenticationProtocol = "MS-CHAPv1"
                                                                                                                                          	RadiusAuthenticationProtocolMschapv2 RadiusAuthenticationProtocol = "MS-CHAPv2"
                                                                                                                                          )

                                                                                                                                            Enum values for RadiusAuthenticationProtocol

                                                                                                                                            func (RadiusAuthenticationProtocol) Values

                                                                                                                                              Values returns all known values for RadiusAuthenticationProtocol. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                              type RadiusSettings

                                                                                                                                              type RadiusSettings struct {
                                                                                                                                              
                                                                                                                                              	// The protocol specified for your RADIUS endpoints.
                                                                                                                                              	AuthenticationProtocol RadiusAuthenticationProtocol
                                                                                                                                              
                                                                                                                                              	// Not currently used.
                                                                                                                                              	DisplayLabel *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 int32
                                                                                                                                              
                                                                                                                                              	// The maximum number of times that communication with the RADIUS server is
                                                                                                                                              	// attempted.
                                                                                                                                              	RadiusRetries int32
                                                                                                                                              
                                                                                                                                              	// An array of strings that contains the fully qualified domain name (FQDN) or IP
                                                                                                                                              	// addresses of the RADIUS server endpoints, or the FQDN or IP addresses of your
                                                                                                                                              	// RADIUS server load balancer.
                                                                                                                                              	RadiusServers []string
                                                                                                                                              
                                                                                                                                              	// The amount of time, in seconds, to wait for the RADIUS server to respond.
                                                                                                                                              	RadiusTimeout int32
                                                                                                                                              
                                                                                                                                              	// Required for enabling RADIUS on the directory.
                                                                                                                                              	SharedSecret *string
                                                                                                                                              
                                                                                                                                              	// Not currently used.
                                                                                                                                              	UseSameUsername bool
                                                                                                                                              }

                                                                                                                                                Contains information about a Remote Authentication Dial In User Service (RADIUS) server.

                                                                                                                                                type RadiusStatus

                                                                                                                                                type RadiusStatus string
                                                                                                                                                const (
                                                                                                                                                	RadiusStatusCreating  RadiusStatus = "Creating"
                                                                                                                                                	RadiusStatusCompleted RadiusStatus = "Completed"
                                                                                                                                                	RadiusStatusFailed    RadiusStatus = "Failed"
                                                                                                                                                )

                                                                                                                                                  Enum values for RadiusStatus

                                                                                                                                                  func (RadiusStatus) Values

                                                                                                                                                  func (RadiusStatus) Values() []RadiusStatus

                                                                                                                                                    Values returns all known values for RadiusStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                    type RegionDescription

                                                                                                                                                    type RegionDescription struct {
                                                                                                                                                    
                                                                                                                                                    	// The desired number of domain controllers in the specified Region for the
                                                                                                                                                    	// specified directory.
                                                                                                                                                    	DesiredNumberOfDomainControllers int32
                                                                                                                                                    
                                                                                                                                                    	// The identifier of the directory.
                                                                                                                                                    	DirectoryId *string
                                                                                                                                                    
                                                                                                                                                    	// The date and time that the Region description was last updated.
                                                                                                                                                    	LastUpdatedDateTime *time.Time
                                                                                                                                                    
                                                                                                                                                    	// Specifies when the Region replication began.
                                                                                                                                                    	LaunchTime *time.Time
                                                                                                                                                    
                                                                                                                                                    	// The name of the Region. For example, us-east-1.
                                                                                                                                                    	RegionName *string
                                                                                                                                                    
                                                                                                                                                    	// Specifies whether the Region is the primary Region or an additional Region.
                                                                                                                                                    	RegionType RegionType
                                                                                                                                                    
                                                                                                                                                    	// The status of the replication process for the specified Region.
                                                                                                                                                    	Status DirectoryStage
                                                                                                                                                    
                                                                                                                                                    	// The date and time that the Region status was last updated.
                                                                                                                                                    	StatusLastUpdatedDateTime *time.Time
                                                                                                                                                    
                                                                                                                                                    	// Contains VPC information for the CreateDirectory or CreateMicrosoftAD operation.
                                                                                                                                                    	VpcSettings *DirectoryVpcSettings
                                                                                                                                                    }

                                                                                                                                                      The replicated Region information for a directory.

                                                                                                                                                      type RegionLimitExceededException

                                                                                                                                                      type RegionLimitExceededException struct {
                                                                                                                                                      	Message *string
                                                                                                                                                      
                                                                                                                                                      	RequestId *string
                                                                                                                                                      }

                                                                                                                                                        You have reached the limit for maximum number of simultaneous Region replications per directory.

                                                                                                                                                        func (*RegionLimitExceededException) Error

                                                                                                                                                        func (*RegionLimitExceededException) ErrorCode

                                                                                                                                                        func (e *RegionLimitExceededException) ErrorCode() string

                                                                                                                                                        func (*RegionLimitExceededException) ErrorFault

                                                                                                                                                        func (*RegionLimitExceededException) ErrorMessage

                                                                                                                                                        func (e *RegionLimitExceededException) ErrorMessage() string

                                                                                                                                                        type RegionType

                                                                                                                                                        type RegionType string
                                                                                                                                                        const (
                                                                                                                                                        	RegionTypePrimary    RegionType = "Primary"
                                                                                                                                                        	RegionTypeAdditional RegionType = "Additional"
                                                                                                                                                        )

                                                                                                                                                          Enum values for RegionType

                                                                                                                                                          func (RegionType) Values

                                                                                                                                                          func (RegionType) Values() []RegionType

                                                                                                                                                            Values returns all known values for RegionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                            type RegionsInfo

                                                                                                                                                            type RegionsInfo struct {
                                                                                                                                                            
                                                                                                                                                            	// Lists the Regions where the directory has been replicated, excluding the primary
                                                                                                                                                            	// Region.
                                                                                                                                                            	AdditionalRegions []string
                                                                                                                                                            
                                                                                                                                                            	// The Region where the AWS Managed Microsoft AD directory was originally created.
                                                                                                                                                            	PrimaryRegion *string
                                                                                                                                                            }

                                                                                                                                                              Provides information about the Regions that are configured for multi-Region replication.

                                                                                                                                                              type ReplicationScope

                                                                                                                                                              type ReplicationScope string
                                                                                                                                                              const (
                                                                                                                                                              	ReplicationScopeDomain ReplicationScope = "Domain"
                                                                                                                                                              )

                                                                                                                                                                Enum values for ReplicationScope

                                                                                                                                                                func (ReplicationScope) Values

                                                                                                                                                                  Values returns all known values for ReplicationScope. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                  type SchemaExtensionInfo

                                                                                                                                                                  type SchemaExtensionInfo struct {
                                                                                                                                                                  
                                                                                                                                                                  	// A description of the schema extension.
                                                                                                                                                                  	Description *string
                                                                                                                                                                  
                                                                                                                                                                  	// The identifier of the directory to which the schema extension is applied.
                                                                                                                                                                  	DirectoryId *string
                                                                                                                                                                  
                                                                                                                                                                  	// The date and time that the schema extension was completed.
                                                                                                                                                                  	EndDateTime *time.Time
                                                                                                                                                                  
                                                                                                                                                                  	// The identifier of the schema extension.
                                                                                                                                                                  	SchemaExtensionId *string
                                                                                                                                                                  
                                                                                                                                                                  	// The current status of the schema extension.
                                                                                                                                                                  	SchemaExtensionStatus SchemaExtensionStatus
                                                                                                                                                                  
                                                                                                                                                                  	// The reason for the SchemaExtensionStatus.
                                                                                                                                                                  	SchemaExtensionStatusReason *string
                                                                                                                                                                  
                                                                                                                                                                  	// The date and time that the schema extension started being applied to the
                                                                                                                                                                  	// directory.
                                                                                                                                                                  	StartDateTime *time.Time
                                                                                                                                                                  }

                                                                                                                                                                    Information about a schema extension.

                                                                                                                                                                    type SchemaExtensionStatus

                                                                                                                                                                    type SchemaExtensionStatus string
                                                                                                                                                                    const (
                                                                                                                                                                    	SchemaExtensionStatusInitializing       SchemaExtensionStatus = "Initializing"
                                                                                                                                                                    	SchemaExtensionStatusCreatingSnapshot   SchemaExtensionStatus = "CreatingSnapshot"
                                                                                                                                                                    	SchemaExtensionStatusUpdatingSchema     SchemaExtensionStatus = "UpdatingSchema"
                                                                                                                                                                    	SchemaExtensionStatusReplicating        SchemaExtensionStatus = "Replicating"
                                                                                                                                                                    	SchemaExtensionStatusCancelInProgress   SchemaExtensionStatus = "CancelInProgress"
                                                                                                                                                                    	SchemaExtensionStatusRollbackInProgress SchemaExtensionStatus = "RollbackInProgress"
                                                                                                                                                                    	SchemaExtensionStatusCancelled          SchemaExtensionStatus = "Cancelled"
                                                                                                                                                                    	SchemaExtensionStatusFailed             SchemaExtensionStatus = "Failed"
                                                                                                                                                                    	SchemaExtensionStatusCompleted          SchemaExtensionStatus = "Completed"
                                                                                                                                                                    )

                                                                                                                                                                      Enum values for SchemaExtensionStatus

                                                                                                                                                                      func (SchemaExtensionStatus) Values

                                                                                                                                                                        Values returns all known values for SchemaExtensionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                        type SelectiveAuth

                                                                                                                                                                        type SelectiveAuth string
                                                                                                                                                                        const (
                                                                                                                                                                        	SelectiveAuthEnabled  SelectiveAuth = "Enabled"
                                                                                                                                                                        	SelectiveAuthDisabled SelectiveAuth = "Disabled"
                                                                                                                                                                        )

                                                                                                                                                                          Enum values for SelectiveAuth

                                                                                                                                                                          func (SelectiveAuth) Values

                                                                                                                                                                          func (SelectiveAuth) Values() []SelectiveAuth

                                                                                                                                                                            Values returns all known values for SelectiveAuth. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                            type ServiceException

                                                                                                                                                                            type ServiceException struct {
                                                                                                                                                                            	Message *string
                                                                                                                                                                            
                                                                                                                                                                            	RequestId *string
                                                                                                                                                                            }

                                                                                                                                                                              An exception has occurred in AWS Directory Service.

                                                                                                                                                                              func (*ServiceException) Error

                                                                                                                                                                              func (e *ServiceException) Error() string

                                                                                                                                                                              func (*ServiceException) ErrorCode

                                                                                                                                                                              func (e *ServiceException) ErrorCode() string

                                                                                                                                                                              func (*ServiceException) ErrorFault

                                                                                                                                                                              func (e *ServiceException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                              func (*ServiceException) ErrorMessage

                                                                                                                                                                              func (e *ServiceException) ErrorMessage() string

                                                                                                                                                                              type ShareLimitExceededException

                                                                                                                                                                              type ShareLimitExceededException struct {
                                                                                                                                                                              	Message *string
                                                                                                                                                                              
                                                                                                                                                                              	RequestId *string
                                                                                                                                                                              }

                                                                                                                                                                                The maximum number of AWS accounts that you can share with this directory has been reached.

                                                                                                                                                                                func (*ShareLimitExceededException) Error

                                                                                                                                                                                func (*ShareLimitExceededException) ErrorCode

                                                                                                                                                                                func (e *ShareLimitExceededException) ErrorCode() string

                                                                                                                                                                                func (*ShareLimitExceededException) ErrorFault

                                                                                                                                                                                func (*ShareLimitExceededException) ErrorMessage

                                                                                                                                                                                func (e *ShareLimitExceededException) ErrorMessage() string

                                                                                                                                                                                type ShareMethod

                                                                                                                                                                                type ShareMethod string
                                                                                                                                                                                const (
                                                                                                                                                                                	ShareMethodOrganizations ShareMethod = "ORGANIZATIONS"
                                                                                                                                                                                	ShareMethodHandshake     ShareMethod = "HANDSHAKE"
                                                                                                                                                                                )

                                                                                                                                                                                  Enum values for ShareMethod

                                                                                                                                                                                  func (ShareMethod) Values

                                                                                                                                                                                  func (ShareMethod) Values() []ShareMethod

                                                                                                                                                                                    Values returns all known values for ShareMethod. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                    type ShareStatus

                                                                                                                                                                                    type ShareStatus string
                                                                                                                                                                                    const (
                                                                                                                                                                                    	ShareStatusShared            ShareStatus = "Shared"
                                                                                                                                                                                    	ShareStatusPendingAcceptance ShareStatus = "PendingAcceptance"
                                                                                                                                                                                    	ShareStatusRejected          ShareStatus = "Rejected"
                                                                                                                                                                                    	ShareStatusRejecting         ShareStatus = "Rejecting"
                                                                                                                                                                                    	ShareStatusRejectFailed      ShareStatus = "RejectFailed"
                                                                                                                                                                                    	ShareStatusSharing           ShareStatus = "Sharing"
                                                                                                                                                                                    	ShareStatusShareFailed       ShareStatus = "ShareFailed"
                                                                                                                                                                                    	ShareStatusDeleted           ShareStatus = "Deleted"
                                                                                                                                                                                    	ShareStatusDeleting          ShareStatus = "Deleting"
                                                                                                                                                                                    )

                                                                                                                                                                                      Enum values for ShareStatus

                                                                                                                                                                                      func (ShareStatus) Values

                                                                                                                                                                                      func (ShareStatus) Values() []ShareStatus

                                                                                                                                                                                        Values returns all known values for ShareStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                        type ShareTarget

                                                                                                                                                                                        type ShareTarget struct {
                                                                                                                                                                                        
                                                                                                                                                                                        	// Identifier of the directory consumer account.
                                                                                                                                                                                        	//
                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                        	Id *string
                                                                                                                                                                                        
                                                                                                                                                                                        	// Type of identifier to be used in the Id field.
                                                                                                                                                                                        	//
                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                        	Type TargetType
                                                                                                                                                                                        }

                                                                                                                                                                                          Identifier that contains details about the directory consumer account.

                                                                                                                                                                                          type SharedDirectory

                                                                                                                                                                                          type SharedDirectory struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The date and time that the shared directory was created.
                                                                                                                                                                                          	CreatedDateTime *time.Time
                                                                                                                                                                                          
                                                                                                                                                                                          	// The date and time that the shared directory was last updated.
                                                                                                                                                                                          	LastUpdatedDateTime *time.Time
                                                                                                                                                                                          
                                                                                                                                                                                          	// Identifier of the directory owner account, which contains the directory that has
                                                                                                                                                                                          	// been shared to the consumer account.
                                                                                                                                                                                          	OwnerAccountId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Identifier of the directory in the directory owner account.
                                                                                                                                                                                          	OwnerDirectoryId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The method used when sharing a directory to determine whether the directory
                                                                                                                                                                                          	// should be shared within your AWS organization (ORGANIZATIONS) or with any AWS
                                                                                                                                                                                          	// account by sending a shared directory request (HANDSHAKE).
                                                                                                                                                                                          	ShareMethod ShareMethod
                                                                                                                                                                                          
                                                                                                                                                                                          	// A directory share request that is sent by the directory owner to the directory
                                                                                                                                                                                          	// consumer. The request includes a typed message to help the directory consumer
                                                                                                                                                                                          	// administrator determine whether to approve or reject the share invitation.
                                                                                                                                                                                          	ShareNotes *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Current directory status of the shared AWS Managed Microsoft AD directory.
                                                                                                                                                                                          	ShareStatus ShareStatus
                                                                                                                                                                                          
                                                                                                                                                                                          	// Identifier of the directory consumer account that has access to the shared
                                                                                                                                                                                          	// directory (OwnerDirectoryId) in the directory owner account.
                                                                                                                                                                                          	SharedAccountId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Identifier of the shared directory in the directory consumer account. This
                                                                                                                                                                                          	// identifier is different for each directory owner account.
                                                                                                                                                                                          	SharedDirectoryId *string
                                                                                                                                                                                          }

                                                                                                                                                                                            Details about the shared directory in the directory owner account for which the share request in the directory consumer account has been accepted.

                                                                                                                                                                                            type Snapshot

                                                                                                                                                                                            type Snapshot struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// The directory identifier.
                                                                                                                                                                                            	DirectoryId *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The descriptive name of the snapshot.
                                                                                                                                                                                            	Name *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The snapshot identifier.
                                                                                                                                                                                            	SnapshotId *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The date and time that the snapshot was taken.
                                                                                                                                                                                            	StartTime *time.Time
                                                                                                                                                                                            
                                                                                                                                                                                            	// The snapshot status.
                                                                                                                                                                                            	Status SnapshotStatus
                                                                                                                                                                                            
                                                                                                                                                                                            	// The snapshot type.
                                                                                                                                                                                            	Type SnapshotType
                                                                                                                                                                                            }

                                                                                                                                                                                              Describes a directory snapshot.

                                                                                                                                                                                              type SnapshotLimitExceededException

                                                                                                                                                                                              type SnapshotLimitExceededException struct {
                                                                                                                                                                                              	Message *string
                                                                                                                                                                                              
                                                                                                                                                                                              	RequestId *string
                                                                                                                                                                                              }

                                                                                                                                                                                                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.

                                                                                                                                                                                                func (*SnapshotLimitExceededException) Error

                                                                                                                                                                                                func (*SnapshotLimitExceededException) ErrorCode

                                                                                                                                                                                                func (e *SnapshotLimitExceededException) ErrorCode() string

                                                                                                                                                                                                func (*SnapshotLimitExceededException) ErrorFault

                                                                                                                                                                                                func (*SnapshotLimitExceededException) ErrorMessage

                                                                                                                                                                                                func (e *SnapshotLimitExceededException) ErrorMessage() string

                                                                                                                                                                                                type SnapshotLimits

                                                                                                                                                                                                type SnapshotLimits struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The current number of manual snapshots of the directory.
                                                                                                                                                                                                	ManualSnapshotsCurrentCount *int32
                                                                                                                                                                                                
                                                                                                                                                                                                	// The maximum number of manual snapshots allowed.
                                                                                                                                                                                                	ManualSnapshotsLimit *int32
                                                                                                                                                                                                
                                                                                                                                                                                                	// Indicates if the manual snapshot limit has been reached.
                                                                                                                                                                                                	ManualSnapshotsLimitReached bool
                                                                                                                                                                                                }

                                                                                                                                                                                                  Contains manual snapshot limit information for a directory.

                                                                                                                                                                                                  type SnapshotStatus

                                                                                                                                                                                                  type SnapshotStatus string
                                                                                                                                                                                                  const (
                                                                                                                                                                                                  	SnapshotStatusCreating  SnapshotStatus = "Creating"
                                                                                                                                                                                                  	SnapshotStatusCompleted SnapshotStatus = "Completed"
                                                                                                                                                                                                  	SnapshotStatusFailed    SnapshotStatus = "Failed"
                                                                                                                                                                                                  )

                                                                                                                                                                                                    Enum values for SnapshotStatus

                                                                                                                                                                                                    func (SnapshotStatus) Values

                                                                                                                                                                                                    func (SnapshotStatus) Values() []SnapshotStatus

                                                                                                                                                                                                      Values returns all known values for SnapshotStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                      type SnapshotType

                                                                                                                                                                                                      type SnapshotType string
                                                                                                                                                                                                      const (
                                                                                                                                                                                                      	SnapshotTypeAuto   SnapshotType = "Auto"
                                                                                                                                                                                                      	SnapshotTypeManual SnapshotType = "Manual"
                                                                                                                                                                                                      )

                                                                                                                                                                                                        Enum values for SnapshotType

                                                                                                                                                                                                        func (SnapshotType) Values

                                                                                                                                                                                                        func (SnapshotType) Values() []SnapshotType

                                                                                                                                                                                                          Values returns all known values for SnapshotType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                          type Tag

                                                                                                                                                                                                          type Tag struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// 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}_.:/=+\\-]*)$").
                                                                                                                                                                                                          	//
                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                          	Key *string
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// 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}_.:/=+\\-]*)$").
                                                                                                                                                                                                          	//
                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                          	Value *string
                                                                                                                                                                                                          }

                                                                                                                                                                                                            Metadata assigned to a directory consisting of a key-value pair.

                                                                                                                                                                                                            type TagLimitExceededException

                                                                                                                                                                                                            type TagLimitExceededException struct {
                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	RequestId *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                              The maximum allowed number of tags was exceeded.

                                                                                                                                                                                                              func (*TagLimitExceededException) Error

                                                                                                                                                                                                              func (e *TagLimitExceededException) Error() string

                                                                                                                                                                                                              func (*TagLimitExceededException) ErrorCode

                                                                                                                                                                                                              func (e *TagLimitExceededException) ErrorCode() string

                                                                                                                                                                                                              func (*TagLimitExceededException) ErrorFault

                                                                                                                                                                                                              func (*TagLimitExceededException) ErrorMessage

                                                                                                                                                                                                              func (e *TagLimitExceededException) ErrorMessage() string

                                                                                                                                                                                                              type TargetType

                                                                                                                                                                                                              type TargetType string
                                                                                                                                                                                                              const (
                                                                                                                                                                                                              	TargetTypeAccount TargetType = "ACCOUNT"
                                                                                                                                                                                                              )

                                                                                                                                                                                                                Enum values for TargetType

                                                                                                                                                                                                                func (TargetType) Values

                                                                                                                                                                                                                func (TargetType) Values() []TargetType

                                                                                                                                                                                                                  Values returns all known values for TargetType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                  type TopicStatus

                                                                                                                                                                                                                  type TopicStatus string
                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                  	TopicStatusRegistered    TopicStatus = "Registered"
                                                                                                                                                                                                                  	TopicStatusTopicNotFound TopicStatus = "Topic not found"
                                                                                                                                                                                                                  	TopicStatusFailed        TopicStatus = "Failed"
                                                                                                                                                                                                                  	TopicStatusDeleted       TopicStatus = "Deleted"
                                                                                                                                                                                                                  )

                                                                                                                                                                                                                    Enum values for TopicStatus

                                                                                                                                                                                                                    func (TopicStatus) Values

                                                                                                                                                                                                                    func (TopicStatus) Values() []TopicStatus

                                                                                                                                                                                                                      Values returns all known values for TopicStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                      type Trust

                                                                                                                                                                                                                      type Trust struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The date and time that the trust relationship was created.
                                                                                                                                                                                                                      	CreatedDateTime *time.Time
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The Directory ID of the AWS directory involved in the trust relationship.
                                                                                                                                                                                                                      	DirectoryId *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The date and time that the trust relationship was last updated.
                                                                                                                                                                                                                      	LastUpdatedDateTime *time.Time
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The Fully Qualified Domain Name (FQDN) of the external domain involved in the
                                                                                                                                                                                                                      	// trust relationship.
                                                                                                                                                                                                                      	RemoteDomainName *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Current state of selective authentication for the trust.
                                                                                                                                                                                                                      	SelectiveAuth SelectiveAuth
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The date and time that the TrustState was last updated.
                                                                                                                                                                                                                      	StateLastUpdatedDateTime *time.Time
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The trust relationship direction.
                                                                                                                                                                                                                      	TrustDirection TrustDirection
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The unique ID of the trust relationship.
                                                                                                                                                                                                                      	TrustId *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The trust relationship state.
                                                                                                                                                                                                                      	TrustState TrustState
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The reason for the TrustState.
                                                                                                                                                                                                                      	TrustStateReason *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The trust relationship type. Forest is the default.
                                                                                                                                                                                                                      	TrustType TrustType
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        Describes a trust relationship between an AWS Managed Microsoft AD directory and an external domain.

                                                                                                                                                                                                                        type TrustDirection

                                                                                                                                                                                                                        type TrustDirection string
                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                        	TrustDirectionOneWayOutgoing TrustDirection = "One-Way: Outgoing"
                                                                                                                                                                                                                        	TrustDirectionOneWayIncoming TrustDirection = "One-Way: Incoming"
                                                                                                                                                                                                                        	TrustDirectionTwoWay         TrustDirection = "Two-Way"
                                                                                                                                                                                                                        )

                                                                                                                                                                                                                          Enum values for TrustDirection

                                                                                                                                                                                                                          func (TrustDirection) Values

                                                                                                                                                                                                                          func (TrustDirection) Values() []TrustDirection

                                                                                                                                                                                                                            Values returns all known values for TrustDirection. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                            type TrustState

                                                                                                                                                                                                                            type TrustState string
                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                            	TrustStateCreating     TrustState = "Creating"
                                                                                                                                                                                                                            	TrustStateCreated      TrustState = "Created"
                                                                                                                                                                                                                            	TrustStateVerifying    TrustState = "Verifying"
                                                                                                                                                                                                                            	TrustStateVerifyFailed TrustState = "VerifyFailed"
                                                                                                                                                                                                                            	TrustStateVerified     TrustState = "Verified"
                                                                                                                                                                                                                            	TrustStateUpdating     TrustState = "Updating"
                                                                                                                                                                                                                            	TrustStateUpdateFailed TrustState = "UpdateFailed"
                                                                                                                                                                                                                            	TrustStateUpdated      TrustState = "Updated"
                                                                                                                                                                                                                            	TrustStateDeleting     TrustState = "Deleting"
                                                                                                                                                                                                                            	TrustStateDeleted      TrustState = "Deleted"
                                                                                                                                                                                                                            	TrustStateFailed       TrustState = "Failed"
                                                                                                                                                                                                                            )

                                                                                                                                                                                                                              Enum values for TrustState

                                                                                                                                                                                                                              func (TrustState) Values

                                                                                                                                                                                                                              func (TrustState) Values() []TrustState

                                                                                                                                                                                                                                Values returns all known values for TrustState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                type TrustType

                                                                                                                                                                                                                                type TrustType string
                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                	TrustTypeForest   TrustType = "Forest"
                                                                                                                                                                                                                                	TrustTypeExternal TrustType = "External"
                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                  Enum values for TrustType

                                                                                                                                                                                                                                  func (TrustType) Values

                                                                                                                                                                                                                                  func (TrustType) Values() []TrustType

                                                                                                                                                                                                                                    Values returns all known values for TrustType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                    type UnshareTarget

                                                                                                                                                                                                                                    type UnshareTarget struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Identifier of the directory consumer account.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                    	Id *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Type of identifier to be used in the Id field.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                    	Type TargetType
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      Identifier that contains details about the directory consumer account with whom the directory is being unshared.

                                                                                                                                                                                                                                      type UnsupportedOperationException

                                                                                                                                                                                                                                      type UnsupportedOperationException struct {
                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	RequestId *string
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        The operation is not supported.

                                                                                                                                                                                                                                        func (*UnsupportedOperationException) Error

                                                                                                                                                                                                                                        func (*UnsupportedOperationException) ErrorCode

                                                                                                                                                                                                                                        func (e *UnsupportedOperationException) ErrorCode() string

                                                                                                                                                                                                                                        func (*UnsupportedOperationException) ErrorFault

                                                                                                                                                                                                                                        func (*UnsupportedOperationException) ErrorMessage

                                                                                                                                                                                                                                        func (e *UnsupportedOperationException) ErrorMessage() string

                                                                                                                                                                                                                                        type UserDoesNotExistException

                                                                                                                                                                                                                                        type UserDoesNotExistException struct {
                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	RequestId *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          The user provided a username that does not exist in your directory.

                                                                                                                                                                                                                                          func (*UserDoesNotExistException) Error

                                                                                                                                                                                                                                          func (e *UserDoesNotExistException) Error() string

                                                                                                                                                                                                                                          func (*UserDoesNotExistException) ErrorCode

                                                                                                                                                                                                                                          func (e *UserDoesNotExistException) ErrorCode() string

                                                                                                                                                                                                                                          func (*UserDoesNotExistException) ErrorFault

                                                                                                                                                                                                                                          func (*UserDoesNotExistException) ErrorMessage

                                                                                                                                                                                                                                          func (e *UserDoesNotExistException) ErrorMessage() string