directoryservice/types/enums.go

// Code generated by smithy-go-codegen DO NOT EDIT.

package types

type CertificateState string

// Enum values for CertificateState
const (
	CertificateStateRegistering      CertificateState = "Registering"
	CertificateStateRegistered       CertificateState = "Registered"
	CertificateStateRegisterFailed   CertificateState = "RegisterFailed"
	CertificateStateDeregistering    CertificateState = "Deregistering"
	CertificateStateDeregistered     CertificateState = "Deregistered"
	CertificateStateDeregisterFailed CertificateState = "DeregisterFailed"
)

// 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.
func (CertificateState) Values() []CertificateState {
	return []CertificateState{
		"Registering",
		"Registered",
		"RegisterFailed",
		"Deregistering",
		"Deregistered",
		"DeregisterFailed",
	}
}

type CertificateType string

// Enum values for CertificateType
const (
	CertificateTypeClientCertAuth CertificateType = "ClientCertAuth"
	CertificateTypeClientLdaps    CertificateType = "ClientLDAPS"
)

// 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.
func (CertificateType) Values() []CertificateType {
	return []CertificateType{
		"ClientCertAuth",
		"ClientLDAPS",
	}
}

type ClientAuthenticationType string

// Enum values for ClientAuthenticationType
const (
	ClientAuthenticationTypeSmartCard ClientAuthenticationType = "SmartCard"
)

// 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.
func (ClientAuthenticationType) Values() []ClientAuthenticationType {
	return []ClientAuthenticationType{
		"SmartCard",
	}
}

type DirectoryEdition string

// Enum values for DirectoryEdition
const (
	DirectoryEditionEnterprise DirectoryEdition = "Enterprise"
	DirectoryEditionStandard   DirectoryEdition = "Standard"
)

// 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.
func (DirectoryEdition) Values() []DirectoryEdition {
	return []DirectoryEdition{
		"Enterprise",
		"Standard",
	}
}

type DirectorySize string

// Enum values for DirectorySize
const (
	DirectorySizeSmall DirectorySize = "Small"
	DirectorySizeLarge DirectorySize = "Large"
)

// 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.
func (DirectorySize) Values() []DirectorySize {
	return []DirectorySize{
		"Small",
		"Large",
	}
}

type DirectoryStage string

// Enum values for DirectoryStage
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"
)

// 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.
func (DirectoryStage) Values() []DirectoryStage {
	return []DirectoryStage{
		"Requested",
		"Creating",
		"Created",
		"Active",
		"Inoperable",
		"Impaired",
		"Restoring",
		"RestoreFailed",
		"Deleting",
		"Deleted",
		"Failed",
	}
}

type DirectoryType string

// Enum values for DirectoryType
const (
	DirectoryTypeSimpleAd          DirectoryType = "SimpleAD"
	DirectoryTypeAdConnector       DirectoryType = "ADConnector"
	DirectoryTypeMicrosoftAd       DirectoryType = "MicrosoftAD"
	DirectoryTypeSharedMicrosoftAd DirectoryType = "SharedMicrosoftAD"
)

// 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.
func (DirectoryType) Values() []DirectoryType {
	return []DirectoryType{
		"SimpleAD",
		"ADConnector",
		"MicrosoftAD",
		"SharedMicrosoftAD",
	}
}

type DomainControllerStatus string

// Enum values for DomainControllerStatus
const (
	DomainControllerStatusCreating  DomainControllerStatus = "Creating"
	DomainControllerStatusActive    DomainControllerStatus = "Active"
	DomainControllerStatusImpaired  DomainControllerStatus = "Impaired"
	DomainControllerStatusRestoring DomainControllerStatus = "Restoring"
	DomainControllerStatusDeleting  DomainControllerStatus = "Deleting"
	DomainControllerStatusDeleted   DomainControllerStatus = "Deleted"
	DomainControllerStatusFailed    DomainControllerStatus = "Failed"
)

// 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.
func (DomainControllerStatus) Values() []DomainControllerStatus {
	return []DomainControllerStatus{
		"Creating",
		"Active",
		"Impaired",
		"Restoring",
		"Deleting",
		"Deleted",
		"Failed",
	}
}

type IpRouteStatusMsg string

// Enum values for IpRouteStatusMsg
const (
	IpRouteStatusMsgAdding       IpRouteStatusMsg = "Adding"
	IpRouteStatusMsgAdded        IpRouteStatusMsg = "Added"
	IpRouteStatusMsgRemoving     IpRouteStatusMsg = "Removing"
	IpRouteStatusMsgRemoved      IpRouteStatusMsg = "Removed"
	IpRouteStatusMsgAddFailed    IpRouteStatusMsg = "AddFailed"
	IpRouteStatusMsgRemoveFailed IpRouteStatusMsg = "RemoveFailed"
)

// 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.
func (IpRouteStatusMsg) Values() []IpRouteStatusMsg {
	return []IpRouteStatusMsg{
		"Adding",
		"Added",
		"Removing",
		"Removed",
		"AddFailed",
		"RemoveFailed",
	}
}

type LDAPSStatus string

// Enum values for LDAPSStatus
const (
	LDAPSStatusEnabling     LDAPSStatus = "Enabling"
	LDAPSStatusEnabled      LDAPSStatus = "Enabled"
	LDAPSStatusEnableFailed LDAPSStatus = "EnableFailed"
	LDAPSStatusDisabled     LDAPSStatus = "Disabled"
)

// 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.
func (LDAPSStatus) Values() []LDAPSStatus {
	return []LDAPSStatus{
		"Enabling",
		"Enabled",
		"EnableFailed",
		"Disabled",
	}
}

type LDAPSType string

// Enum values for LDAPSType
const (
	LDAPSTypeClient LDAPSType = "Client"
)

// 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.
func (LDAPSType) Values() []LDAPSType {
	return []LDAPSType{
		"Client",
	}
}

type RadiusAuthenticationProtocol string

// Enum values for RadiusAuthenticationProtocol
const (
	RadiusAuthenticationProtocolPap      RadiusAuthenticationProtocol = "PAP"
	RadiusAuthenticationProtocolChap     RadiusAuthenticationProtocol = "CHAP"
	RadiusAuthenticationProtocolMschapv1 RadiusAuthenticationProtocol = "MS-CHAPv1"
	RadiusAuthenticationProtocolMschapv2 RadiusAuthenticationProtocol = "MS-CHAPv2"
)

// 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.
func (RadiusAuthenticationProtocol) Values() []RadiusAuthenticationProtocol {
	return []RadiusAuthenticationProtocol{
		"PAP",
		"CHAP",
		"MS-CHAPv1",
		"MS-CHAPv2",
	}
}

type RadiusStatus string

// Enum values for RadiusStatus
const (
	RadiusStatusCreating  RadiusStatus = "Creating"
	RadiusStatusCompleted RadiusStatus = "Completed"
	RadiusStatusFailed    RadiusStatus = "Failed"
)

// 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.
func (RadiusStatus) Values() []RadiusStatus {
	return []RadiusStatus{
		"Creating",
		"Completed",
		"Failed",
	}
}

type RegionType string

// Enum values for RegionType
const (
	RegionTypePrimary    RegionType = "Primary"
	RegionTypeAdditional RegionType = "Additional"
)

// 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.
func (RegionType) Values() []RegionType {
	return []RegionType{
		"Primary",
		"Additional",
	}
}

type ReplicationScope string

// Enum values for ReplicationScope
const (
	ReplicationScopeDomain ReplicationScope = "Domain"
)

// 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.
func (ReplicationScope) Values() []ReplicationScope {
	return []ReplicationScope{
		"Domain",
	}
}

type SchemaExtensionStatus string

// Enum values for SchemaExtensionStatus
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"
)

// 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.
func (SchemaExtensionStatus) Values() []SchemaExtensionStatus {
	return []SchemaExtensionStatus{
		"Initializing",
		"CreatingSnapshot",
		"UpdatingSchema",
		"Replicating",
		"CancelInProgress",
		"RollbackInProgress",
		"Cancelled",
		"Failed",
		"Completed",
	}
}

type SelectiveAuth string

// Enum values for SelectiveAuth
const (
	SelectiveAuthEnabled  SelectiveAuth = "Enabled"
	SelectiveAuthDisabled SelectiveAuth = "Disabled"
)

// 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.
func (SelectiveAuth) Values() []SelectiveAuth {
	return []SelectiveAuth{
		"Enabled",
		"Disabled",
	}
}

type ShareMethod string

// Enum values for ShareMethod
const (
	ShareMethodOrganizations ShareMethod = "ORGANIZATIONS"
	ShareMethodHandshake     ShareMethod = "HANDSHAKE"
)

// 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.
func (ShareMethod) Values() []ShareMethod {
	return []ShareMethod{
		"ORGANIZATIONS",
		"HANDSHAKE",
	}
}

type ShareStatus string

// Enum values for ShareStatus
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"
)

// 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.
func (ShareStatus) Values() []ShareStatus {
	return []ShareStatus{
		"Shared",
		"PendingAcceptance",
		"Rejected",
		"Rejecting",
		"RejectFailed",
		"Sharing",
		"ShareFailed",
		"Deleted",
		"Deleting",
	}
}

type SnapshotStatus string

// Enum values for SnapshotStatus
const (
	SnapshotStatusCreating  SnapshotStatus = "Creating"
	SnapshotStatusCompleted SnapshotStatus = "Completed"
	SnapshotStatusFailed    SnapshotStatus = "Failed"
)

// 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.
func (SnapshotStatus) Values() []SnapshotStatus {
	return []SnapshotStatus{
		"Creating",
		"Completed",
		"Failed",
	}
}

type SnapshotType string

// Enum values for SnapshotType
const (
	SnapshotTypeAuto   SnapshotType = "Auto"
	SnapshotTypeManual SnapshotType = "Manual"
)

// 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.
func (SnapshotType) Values() []SnapshotType {
	return []SnapshotType{
		"Auto",
		"Manual",
	}
}

type TargetType string

// Enum values for TargetType
const (
	TargetTypeAccount TargetType = "ACCOUNT"
)

// 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.
func (TargetType) Values() []TargetType {
	return []TargetType{
		"ACCOUNT",
	}
}

type TopicStatus string

// Enum values for TopicStatus
const (
	TopicStatusRegistered    TopicStatus = "Registered"
	TopicStatusTopicNotFound TopicStatus = "Topic not found"
	TopicStatusFailed        TopicStatus = "Failed"
	TopicStatusDeleted       TopicStatus = "Deleted"
)

// 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.
func (TopicStatus) Values() []TopicStatus {
	return []TopicStatus{
		"Registered",
		"Topic not found",
		"Failed",
		"Deleted",
	}
}

type TrustDirection string

// Enum values for TrustDirection
const (
	TrustDirectionOneWayOutgoing TrustDirection = "One-Way: Outgoing"
	TrustDirectionOneWayIncoming TrustDirection = "One-Way: Incoming"
	TrustDirectionTwoWay         TrustDirection = "Two-Way"
)

// 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.
func (TrustDirection) Values() []TrustDirection {
	return []TrustDirection{
		"One-Way: Outgoing",
		"One-Way: Incoming",
		"Two-Way",
	}
}

type TrustState string

// Enum values for TrustState
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"
)

// 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.
func (TrustState) Values() []TrustState {
	return []TrustState{
		"Creating",
		"Created",
		"Verifying",
		"VerifyFailed",
		"Verified",
		"Updating",
		"UpdateFailed",
		"Updated",
		"Deleting",
		"Deleted",
		"Failed",
	}
}

type TrustType string

// Enum values for TrustType
const (
	TrustTypeForest   TrustType = "Forest"
	TrustTypeExternal TrustType = "External"
)

// 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.
func (TrustType) Values() []TrustType {
	return []TrustType{
		"Forest",
		"External",
	}
}