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

package ssm

type AssociationComplianceSeverity string

// Enum values for AssociationComplianceSeverity
const (
	AssociationComplianceSeverityCritical    AssociationComplianceSeverity = "CRITICAL"
	AssociationComplianceSeverityHigh        AssociationComplianceSeverity = "HIGH"
	AssociationComplianceSeverityMedium      AssociationComplianceSeverity = "MEDIUM"
	AssociationComplianceSeverityLow         AssociationComplianceSeverity = "LOW"
	AssociationComplianceSeverityUnspecified AssociationComplianceSeverity = "UNSPECIFIED"
)

func (enum AssociationComplianceSeverity) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AssociationComplianceSeverity) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AssociationExecutionFilterKey string

// Enum values for AssociationExecutionFilterKey
const (
	AssociationExecutionFilterKeyExecutionId AssociationExecutionFilterKey = "ExecutionId"
	AssociationExecutionFilterKeyStatus      AssociationExecutionFilterKey = "Status"
	AssociationExecutionFilterKeyCreatedTime AssociationExecutionFilterKey = "CreatedTime"
)

func (enum AssociationExecutionFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AssociationExecutionFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AssociationExecutionTargetsFilterKey string

// Enum values for AssociationExecutionTargetsFilterKey
const (
	AssociationExecutionTargetsFilterKeyStatus       AssociationExecutionTargetsFilterKey = "Status"
	AssociationExecutionTargetsFilterKeyResourceId   AssociationExecutionTargetsFilterKey = "ResourceId"
	AssociationExecutionTargetsFilterKeyResourceType AssociationExecutionTargetsFilterKey = "ResourceType"
)

func (enum AssociationExecutionTargetsFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AssociationExecutionTargetsFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AssociationFilterKey string

// Enum values for AssociationFilterKey
const (
	AssociationFilterKeyInstanceId            AssociationFilterKey = "InstanceId"
	AssociationFilterKeyName                  AssociationFilterKey = "Name"
	AssociationFilterKeyAssociationId         AssociationFilterKey = "AssociationId"
	AssociationFilterKeyAssociationStatusName AssociationFilterKey = "AssociationStatusName"
	AssociationFilterKeyLastExecutedBefore    AssociationFilterKey = "LastExecutedBefore"
	AssociationFilterKeyLastExecutedAfter     AssociationFilterKey = "LastExecutedAfter"
	AssociationFilterKeyAssociationName       AssociationFilterKey = "AssociationName"
)

func (enum AssociationFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AssociationFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AssociationFilterOperatorType string

// Enum values for AssociationFilterOperatorType
const (
	AssociationFilterOperatorTypeEqual       AssociationFilterOperatorType = "EQUAL"
	AssociationFilterOperatorTypeLessThan    AssociationFilterOperatorType = "LESS_THAN"
	AssociationFilterOperatorTypeGreaterThan AssociationFilterOperatorType = "GREATER_THAN"
)

func (enum AssociationFilterOperatorType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AssociationFilterOperatorType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AssociationStatusName string

// Enum values for AssociationStatusName
const (
	AssociationStatusNamePending AssociationStatusName = "Pending"
	AssociationStatusNameSuccess AssociationStatusName = "Success"
	AssociationStatusNameFailed  AssociationStatusName = "Failed"
)

func (enum AssociationStatusName) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AssociationStatusName) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AttachmentHashType string

// Enum values for AttachmentHashType
const (
	AttachmentHashTypeSha256 AttachmentHashType = "Sha256"
)

func (enum AttachmentHashType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AttachmentHashType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AttachmentsSourceKey string

// Enum values for AttachmentsSourceKey
const (
	AttachmentsSourceKeySourceUrl AttachmentsSourceKey = "SourceUrl"
	AttachmentsSourceKeyS3fileUrl AttachmentsSourceKey = "S3FileUrl"
)

func (enum AttachmentsSourceKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AttachmentsSourceKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutomationExecutionFilterKey string

// Enum values for AutomationExecutionFilterKey
const (
	AutomationExecutionFilterKeyDocumentNamePrefix AutomationExecutionFilterKey = "DocumentNamePrefix"
	AutomationExecutionFilterKeyExecutionStatus    AutomationExecutionFilterKey = "ExecutionStatus"
	AutomationExecutionFilterKeyExecutionId        AutomationExecutionFilterKey = "ExecutionId"
	AutomationExecutionFilterKeyParentExecutionId  AutomationExecutionFilterKey = "ParentExecutionId"
	AutomationExecutionFilterKeyCurrentAction      AutomationExecutionFilterKey = "CurrentAction"
	AutomationExecutionFilterKeyStartTimeBefore    AutomationExecutionFilterKey = "StartTimeBefore"
	AutomationExecutionFilterKeyStartTimeAfter     AutomationExecutionFilterKey = "StartTimeAfter"
	AutomationExecutionFilterKeyAutomationType     AutomationExecutionFilterKey = "AutomationType"
)

func (enum AutomationExecutionFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutomationExecutionFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutomationExecutionStatus string

// Enum values for AutomationExecutionStatus
const (
	AutomationExecutionStatusPending    AutomationExecutionStatus = "Pending"
	AutomationExecutionStatusInProgress AutomationExecutionStatus = "InProgress"
	AutomationExecutionStatusWaiting    AutomationExecutionStatus = "Waiting"
	AutomationExecutionStatusSuccess    AutomationExecutionStatus = "Success"
	AutomationExecutionStatusTimedOut   AutomationExecutionStatus = "TimedOut"
	AutomationExecutionStatusCancelling AutomationExecutionStatus = "Cancelling"
	AutomationExecutionStatusCancelled  AutomationExecutionStatus = "Cancelled"
	AutomationExecutionStatusFailed     AutomationExecutionStatus = "Failed"
)

func (enum AutomationExecutionStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutomationExecutionStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutomationType string

// Enum values for AutomationType
const (
	AutomationTypeCrossAccount AutomationType = "CrossAccount"
	AutomationTypeLocal        AutomationType = "Local"
)

func (enum AutomationType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutomationType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CalendarState string

// Enum values for CalendarState
const (
	CalendarStateOpen   CalendarState = "OPEN"
	CalendarStateClosed CalendarState = "CLOSED"
)

func (enum CalendarState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CalendarState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CommandFilterKey string

// Enum values for CommandFilterKey
const (
	CommandFilterKeyInvokedAfter   CommandFilterKey = "InvokedAfter"
	CommandFilterKeyInvokedBefore  CommandFilterKey = "InvokedBefore"
	CommandFilterKeyStatus         CommandFilterKey = "Status"
	CommandFilterKeyExecutionStage CommandFilterKey = "ExecutionStage"
	CommandFilterKeyDocumentName   CommandFilterKey = "DocumentName"
)

func (enum CommandFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CommandFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CommandInvocationStatus string

// Enum values for CommandInvocationStatus
const (
	CommandInvocationStatusPending    CommandInvocationStatus = "Pending"
	CommandInvocationStatusInProgress CommandInvocationStatus = "InProgress"
	CommandInvocationStatusDelayed    CommandInvocationStatus = "Delayed"
	CommandInvocationStatusSuccess    CommandInvocationStatus = "Success"
	CommandInvocationStatusCancelled  CommandInvocationStatus = "Cancelled"
	CommandInvocationStatusTimedOut   CommandInvocationStatus = "TimedOut"
	CommandInvocationStatusFailed     CommandInvocationStatus = "Failed"
	CommandInvocationStatusCancelling CommandInvocationStatus = "Cancelling"
)

func (enum CommandInvocationStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CommandInvocationStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CommandPluginStatus string

// Enum values for CommandPluginStatus
const (
	CommandPluginStatusPending    CommandPluginStatus = "Pending"
	CommandPluginStatusInProgress CommandPluginStatus = "InProgress"
	CommandPluginStatusSuccess    CommandPluginStatus = "Success"
	CommandPluginStatusTimedOut   CommandPluginStatus = "TimedOut"
	CommandPluginStatusCancelled  CommandPluginStatus = "Cancelled"
	CommandPluginStatusFailed     CommandPluginStatus = "Failed"
)

func (enum CommandPluginStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CommandPluginStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CommandStatus string

// Enum values for CommandStatus
const (
	CommandStatusPending    CommandStatus = "Pending"
	CommandStatusInProgress CommandStatus = "InProgress"
	CommandStatusSuccess    CommandStatus = "Success"
	CommandStatusCancelled  CommandStatus = "Cancelled"
	CommandStatusFailed     CommandStatus = "Failed"
	CommandStatusTimedOut   CommandStatus = "TimedOut"
	CommandStatusCancelling CommandStatus = "Cancelling"
)

func (enum CommandStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CommandStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ComplianceQueryOperatorType string

// Enum values for ComplianceQueryOperatorType
const (
	ComplianceQueryOperatorTypeEqual       ComplianceQueryOperatorType = "EQUAL"
	ComplianceQueryOperatorTypeNotEqual    ComplianceQueryOperatorType = "NOT_EQUAL"
	ComplianceQueryOperatorTypeBeginWith   ComplianceQueryOperatorType = "BEGIN_WITH"
	ComplianceQueryOperatorTypeLessThan    ComplianceQueryOperatorType = "LESS_THAN"
	ComplianceQueryOperatorTypeGreaterThan ComplianceQueryOperatorType = "GREATER_THAN"
)

func (enum ComplianceQueryOperatorType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ComplianceQueryOperatorType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ComplianceSeverity string

// Enum values for ComplianceSeverity
const (
	ComplianceSeverityCritical      ComplianceSeverity = "CRITICAL"
	ComplianceSeverityHigh          ComplianceSeverity = "HIGH"
	ComplianceSeverityMedium        ComplianceSeverity = "MEDIUM"
	ComplianceSeverityLow           ComplianceSeverity = "LOW"
	ComplianceSeverityInformational ComplianceSeverity = "INFORMATIONAL"
	ComplianceSeverityUnspecified   ComplianceSeverity = "UNSPECIFIED"
)

func (enum ComplianceSeverity) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ComplianceSeverity) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ComplianceStatus string

// Enum values for ComplianceStatus
const (
	ComplianceStatusCompliant    ComplianceStatus = "COMPLIANT"
	ComplianceStatusNonCompliant ComplianceStatus = "NON_COMPLIANT"
)

func (enum ComplianceStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ComplianceStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ConnectionStatus string

// Enum values for ConnectionStatus
const (
	ConnectionStatusConnected    ConnectionStatus = "Connected"
	ConnectionStatusNotConnected ConnectionStatus = "NotConnected"
)

func (enum ConnectionStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ConnectionStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DescribeActivationsFilterKeys string

// Enum values for DescribeActivationsFilterKeys
const (
	DescribeActivationsFilterKeysActivationIds       DescribeActivationsFilterKeys = "ActivationIds"
	DescribeActivationsFilterKeysDefaultInstanceName DescribeActivationsFilterKeys = "DefaultInstanceName"
	DescribeActivationsFilterKeysIamRole             DescribeActivationsFilterKeys = "IamRole"
)

func (enum DescribeActivationsFilterKeys) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DescribeActivationsFilterKeys) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DocumentFilterKey string

// Enum values for DocumentFilterKey
const (
	DocumentFilterKeyName          DocumentFilterKey = "Name"
	DocumentFilterKeyOwner         DocumentFilterKey = "Owner"
	DocumentFilterKeyPlatformTypes DocumentFilterKey = "PlatformTypes"
	DocumentFilterKeyDocumentType  DocumentFilterKey = "DocumentType"
)

func (enum DocumentFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DocumentFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DocumentFormat string

// Enum values for DocumentFormat
const (
	DocumentFormatYaml DocumentFormat = "YAML"
	DocumentFormatJson DocumentFormat = "JSON"
	DocumentFormatText DocumentFormat = "TEXT"
)

func (enum DocumentFormat) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DocumentFormat) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DocumentHashType string

// Enum values for DocumentHashType
const (
	DocumentHashTypeSha256 DocumentHashType = "Sha256"
	DocumentHashTypeSha1   DocumentHashType = "Sha1"
)

func (enum DocumentHashType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DocumentHashType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DocumentParameterType string

// Enum values for DocumentParameterType
const (
	DocumentParameterTypeString     DocumentParameterType = "String"
	DocumentParameterTypeStringList DocumentParameterType = "StringList"
)

func (enum DocumentParameterType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DocumentParameterType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DocumentPermissionType string

// Enum values for DocumentPermissionType
const (
	DocumentPermissionTypeShare DocumentPermissionType = "Share"
)

func (enum DocumentPermissionType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DocumentPermissionType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The status of a document.
type DocumentStatus string

// Enum values for DocumentStatus
const (
	DocumentStatusCreating DocumentStatus = "Creating"
	DocumentStatusActive   DocumentStatus = "Active"
	DocumentStatusUpdating DocumentStatus = "Updating"
	DocumentStatusDeleting DocumentStatus = "Deleting"
	DocumentStatusFailed   DocumentStatus = "Failed"
)

func (enum DocumentStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DocumentStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DocumentType string

// Enum values for DocumentType
const (
	DocumentTypeCommand                        DocumentType = "Command"
	DocumentTypePolicy                         DocumentType = "Policy"
	DocumentTypeAutomation                     DocumentType = "Automation"
	DocumentTypeSession                        DocumentType = "Session"
	DocumentTypePackage                        DocumentType = "Package"
	DocumentTypeApplicationConfiguration       DocumentType = "ApplicationConfiguration"
	DocumentTypeApplicationConfigurationSchema DocumentType = "ApplicationConfigurationSchema"
	DocumentTypeDeploymentStrategy             DocumentType = "DeploymentStrategy"
	DocumentTypeChangeCalendar                 DocumentType = "ChangeCalendar"
)

func (enum DocumentType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DocumentType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ExecutionMode string

// Enum values for ExecutionMode
const (
	ExecutionModeAuto        ExecutionMode = "Auto"
	ExecutionModeInteractive ExecutionMode = "Interactive"
)

func (enum ExecutionMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ExecutionMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type Fault string

// Enum values for Fault
const (
	FaultClient  Fault = "Client"
	FaultServer  Fault = "Server"
	FaultUnknown Fault = "Unknown"
)

func (enum Fault) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Fault) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InstanceInformationFilterKey string

// Enum values for InstanceInformationFilterKey
const (
	InstanceInformationFilterKeyInstanceIds       InstanceInformationFilterKey = "InstanceIds"
	InstanceInformationFilterKeyAgentVersion      InstanceInformationFilterKey = "AgentVersion"
	InstanceInformationFilterKeyPingStatus        InstanceInformationFilterKey = "PingStatus"
	InstanceInformationFilterKeyPlatformTypes     InstanceInformationFilterKey = "PlatformTypes"
	InstanceInformationFilterKeyActivationIds     InstanceInformationFilterKey = "ActivationIds"
	InstanceInformationFilterKeyIamRole           InstanceInformationFilterKey = "IamRole"
	InstanceInformationFilterKeyResourceType      InstanceInformationFilterKey = "ResourceType"
	InstanceInformationFilterKeyAssociationStatus InstanceInformationFilterKey = "AssociationStatus"
)

func (enum InstanceInformationFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InstanceInformationFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InstancePatchStateOperatorType string

// Enum values for InstancePatchStateOperatorType
const (
	InstancePatchStateOperatorTypeEqual       InstancePatchStateOperatorType = "Equal"
	InstancePatchStateOperatorTypeNotEqual    InstancePatchStateOperatorType = "NotEqual"
	InstancePatchStateOperatorTypeLessThan    InstancePatchStateOperatorType = "LessThan"
	InstancePatchStateOperatorTypeGreaterThan InstancePatchStateOperatorType = "GreaterThan"
)

func (enum InstancePatchStateOperatorType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InstancePatchStateOperatorType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InventoryAttributeDataType string

// Enum values for InventoryAttributeDataType
const (
	InventoryAttributeDataTypeString InventoryAttributeDataType = "string"
	InventoryAttributeDataTypeNumber InventoryAttributeDataType = "number"
)

func (enum InventoryAttributeDataType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InventoryAttributeDataType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InventoryDeletionStatus string

// Enum values for InventoryDeletionStatus
const (
	InventoryDeletionStatusInProgress InventoryDeletionStatus = "InProgress"
	InventoryDeletionStatusComplete   InventoryDeletionStatus = "Complete"
)

func (enum InventoryDeletionStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InventoryDeletionStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InventoryQueryOperatorType string

// Enum values for InventoryQueryOperatorType
const (
	InventoryQueryOperatorTypeEqual       InventoryQueryOperatorType = "Equal"
	InventoryQueryOperatorTypeNotEqual    InventoryQueryOperatorType = "NotEqual"
	InventoryQueryOperatorTypeBeginWith   InventoryQueryOperatorType = "BeginWith"
	InventoryQueryOperatorTypeLessThan    InventoryQueryOperatorType = "LessThan"
	InventoryQueryOperatorTypeGreaterThan InventoryQueryOperatorType = "GreaterThan"
	InventoryQueryOperatorTypeExists      InventoryQueryOperatorType = "Exists"
)

func (enum InventoryQueryOperatorType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InventoryQueryOperatorType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InventorySchemaDeleteOption string

// Enum values for InventorySchemaDeleteOption
const (
	InventorySchemaDeleteOptionDisableSchema InventorySchemaDeleteOption = "DisableSchema"
	InventorySchemaDeleteOptionDeleteSchema  InventorySchemaDeleteOption = "DeleteSchema"
)

func (enum InventorySchemaDeleteOption) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InventorySchemaDeleteOption) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type LastResourceDataSyncStatus string

// Enum values for LastResourceDataSyncStatus
const (
	LastResourceDataSyncStatusSuccessful LastResourceDataSyncStatus = "Successful"
	LastResourceDataSyncStatusFailed     LastResourceDataSyncStatus = "Failed"
	LastResourceDataSyncStatusInProgress LastResourceDataSyncStatus = "InProgress"
)

func (enum LastResourceDataSyncStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum LastResourceDataSyncStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type MaintenanceWindowExecutionStatus string

// Enum values for MaintenanceWindowExecutionStatus
const (
	MaintenanceWindowExecutionStatusPending            MaintenanceWindowExecutionStatus = "PENDING"
	MaintenanceWindowExecutionStatusInProgress         MaintenanceWindowExecutionStatus = "IN_PROGRESS"
	MaintenanceWindowExecutionStatusSuccess            MaintenanceWindowExecutionStatus = "SUCCESS"
	MaintenanceWindowExecutionStatusFailed             MaintenanceWindowExecutionStatus = "FAILED"
	MaintenanceWindowExecutionStatusTimedOut           MaintenanceWindowExecutionStatus = "TIMED_OUT"
	MaintenanceWindowExecutionStatusCancelling         MaintenanceWindowExecutionStatus = "CANCELLING"
	MaintenanceWindowExecutionStatusCancelled          MaintenanceWindowExecutionStatus = "CANCELLED"
	MaintenanceWindowExecutionStatusSkippedOverlapping MaintenanceWindowExecutionStatus = "SKIPPED_OVERLAPPING"
)

func (enum MaintenanceWindowExecutionStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum MaintenanceWindowExecutionStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type MaintenanceWindowResourceType string

// Enum values for MaintenanceWindowResourceType
const (
	MaintenanceWindowResourceTypeInstance      MaintenanceWindowResourceType = "INSTANCE"
	MaintenanceWindowResourceTypeResourceGroup MaintenanceWindowResourceType = "RESOURCE_GROUP"
)

func (enum MaintenanceWindowResourceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum MaintenanceWindowResourceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type MaintenanceWindowTaskType string

// Enum values for MaintenanceWindowTaskType
const (
	MaintenanceWindowTaskTypeRunCommand    MaintenanceWindowTaskType = "RUN_COMMAND"
	MaintenanceWindowTaskTypeAutomation    MaintenanceWindowTaskType = "AUTOMATION"
	MaintenanceWindowTaskTypeStepFunctions MaintenanceWindowTaskType = "STEP_FUNCTIONS"
	MaintenanceWindowTaskTypeLambda        MaintenanceWindowTaskType = "LAMBDA"
)

func (enum MaintenanceWindowTaskType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum MaintenanceWindowTaskType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotificationEvent string

// Enum values for NotificationEvent
const (
	NotificationEventAll        NotificationEvent = "All"
	NotificationEventInProgress NotificationEvent = "InProgress"
	NotificationEventSuccess    NotificationEvent = "Success"
	NotificationEventTimedOut   NotificationEvent = "TimedOut"
	NotificationEventCancelled  NotificationEvent = "Cancelled"
	NotificationEventFailed     NotificationEvent = "Failed"
)

func (enum NotificationEvent) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotificationEvent) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotificationType string

// Enum values for NotificationType
const (
	NotificationTypeCommand    NotificationType = "Command"
	NotificationTypeInvocation NotificationType = "Invocation"
)

func (enum NotificationType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotificationType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type OperatingSystem string

// Enum values for OperatingSystem
const (
	OperatingSystemWindows               OperatingSystem = "WINDOWS"
	OperatingSystemAmazonLinux           OperatingSystem = "AMAZON_LINUX"
	OperatingSystemAmazonLinux2          OperatingSystem = "AMAZON_LINUX_2"
	OperatingSystemUbuntu                OperatingSystem = "UBUNTU"
	OperatingSystemRedhatEnterpriseLinux OperatingSystem = "REDHAT_ENTERPRISE_LINUX"
	OperatingSystemSuse                  OperatingSystem = "SUSE"
	OperatingSystemCentos                OperatingSystem = "CENTOS"
)

func (enum OperatingSystem) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OperatingSystem) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type OpsFilterOperatorType string

// Enum values for OpsFilterOperatorType
const (
	OpsFilterOperatorTypeEqual       OpsFilterOperatorType = "Equal"
	OpsFilterOperatorTypeNotEqual    OpsFilterOperatorType = "NotEqual"
	OpsFilterOperatorTypeBeginWith   OpsFilterOperatorType = "BeginWith"
	OpsFilterOperatorTypeLessThan    OpsFilterOperatorType = "LessThan"
	OpsFilterOperatorTypeGreaterThan OpsFilterOperatorType = "GreaterThan"
	OpsFilterOperatorTypeExists      OpsFilterOperatorType = "Exists"
)

func (enum OpsFilterOperatorType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OpsFilterOperatorType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type OpsItemDataType string

// Enum values for OpsItemDataType
const (
	OpsItemDataTypeSearchableString OpsItemDataType = "SearchableString"
	OpsItemDataTypeString           OpsItemDataType = "String"
)

func (enum OpsItemDataType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OpsItemDataType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type OpsItemFilterKey string

// Enum values for OpsItemFilterKey
const (
	OpsItemFilterKeyStatus               OpsItemFilterKey = "Status"
	OpsItemFilterKeyCreatedBy            OpsItemFilterKey = "CreatedBy"
	OpsItemFilterKeySource               OpsItemFilterKey = "Source"
	OpsItemFilterKeyPriority             OpsItemFilterKey = "Priority"
	OpsItemFilterKeyTitle                OpsItemFilterKey = "Title"
	OpsItemFilterKeyOpsItemId            OpsItemFilterKey = "OpsItemId"
	OpsItemFilterKeyCreatedTime          OpsItemFilterKey = "CreatedTime"
	OpsItemFilterKeyLastModifiedTime     OpsItemFilterKey = "LastModifiedTime"
	OpsItemFilterKeyOperationalData      OpsItemFilterKey = "OperationalData"
	OpsItemFilterKeyOperationalDataKey   OpsItemFilterKey = "OperationalDataKey"
	OpsItemFilterKeyOperationalDataValue OpsItemFilterKey = "OperationalDataValue"
	OpsItemFilterKeyResourceId           OpsItemFilterKey = "ResourceId"
	OpsItemFilterKeyAutomationId         OpsItemFilterKey = "AutomationId"
	OpsItemFilterKeyCategory             OpsItemFilterKey = "Category"
	OpsItemFilterKeySeverity             OpsItemFilterKey = "Severity"
)

func (enum OpsItemFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OpsItemFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type OpsItemFilterOperator string

// Enum values for OpsItemFilterOperator
const (
	OpsItemFilterOperatorEqual       OpsItemFilterOperator = "Equal"
	OpsItemFilterOperatorContains    OpsItemFilterOperator = "Contains"
	OpsItemFilterOperatorGreaterThan OpsItemFilterOperator = "GreaterThan"
	OpsItemFilterOperatorLessThan    OpsItemFilterOperator = "LessThan"
)

func (enum OpsItemFilterOperator) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OpsItemFilterOperator) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type OpsItemStatus string

// Enum values for OpsItemStatus
const (
	OpsItemStatusOpen       OpsItemStatus = "Open"
	OpsItemStatusInProgress OpsItemStatus = "InProgress"
	OpsItemStatusResolved   OpsItemStatus = "Resolved"
)

func (enum OpsItemStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OpsItemStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ParameterTier string

// Enum values for ParameterTier
const (
	ParameterTierStandard           ParameterTier = "Standard"
	ParameterTierAdvanced           ParameterTier = "Advanced"
	ParameterTierIntelligentTiering ParameterTier = "Intelligent-Tiering"
)

func (enum ParameterTier) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ParameterTier) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ParameterType string

// Enum values for ParameterType
const (
	ParameterTypeString       ParameterType = "String"
	ParameterTypeStringList   ParameterType = "StringList"
	ParameterTypeSecureString ParameterType = "SecureString"
)

func (enum ParameterType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ParameterType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ParametersFilterKey string

// Enum values for ParametersFilterKey
const (
	ParametersFilterKeyName  ParametersFilterKey = "Name"
	ParametersFilterKeyType  ParametersFilterKey = "Type"
	ParametersFilterKeyKeyId ParametersFilterKey = "KeyId"
)

func (enum ParametersFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ParametersFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PatchAction string

// Enum values for PatchAction
const (
	PatchActionAllowAsDependency PatchAction = "ALLOW_AS_DEPENDENCY"
	PatchActionBlock             PatchAction = "BLOCK"
)

func (enum PatchAction) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PatchAction) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PatchComplianceDataState string

// Enum values for PatchComplianceDataState
const (
	PatchComplianceDataStateInstalled              PatchComplianceDataState = "INSTALLED"
	PatchComplianceDataStateInstalledOther         PatchComplianceDataState = "INSTALLED_OTHER"
	PatchComplianceDataStateInstalledPendingReboot PatchComplianceDataState = "INSTALLED_PENDING_REBOOT"
	PatchComplianceDataStateInstalledRejected      PatchComplianceDataState = "INSTALLED_REJECTED"
	PatchComplianceDataStateMissing                PatchComplianceDataState = "MISSING"
	PatchComplianceDataStateNotApplicable          PatchComplianceDataState = "NOT_APPLICABLE"
	PatchComplianceDataStateFailed                 PatchComplianceDataState = "FAILED"
)

func (enum PatchComplianceDataState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PatchComplianceDataState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PatchComplianceLevel string

// Enum values for PatchComplianceLevel
const (
	PatchComplianceLevelCritical      PatchComplianceLevel = "CRITICAL"
	PatchComplianceLevelHigh          PatchComplianceLevel = "HIGH"
	PatchComplianceLevelMedium        PatchComplianceLevel = "MEDIUM"
	PatchComplianceLevelLow           PatchComplianceLevel = "LOW"
	PatchComplianceLevelInformational PatchComplianceLevel = "INFORMATIONAL"
	PatchComplianceLevelUnspecified   PatchComplianceLevel = "UNSPECIFIED"
)

func (enum PatchComplianceLevel) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PatchComplianceLevel) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PatchDeploymentStatus string

// Enum values for PatchDeploymentStatus
const (
	PatchDeploymentStatusApproved         PatchDeploymentStatus = "APPROVED"
	PatchDeploymentStatusPendingApproval  PatchDeploymentStatus = "PENDING_APPROVAL"
	PatchDeploymentStatusExplicitApproved PatchDeploymentStatus = "EXPLICIT_APPROVED"
	PatchDeploymentStatusExplicitRejected PatchDeploymentStatus = "EXPLICIT_REJECTED"
)

func (enum PatchDeploymentStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PatchDeploymentStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PatchFilterKey string

// Enum values for PatchFilterKey
const (
	PatchFilterKeyPatchSet       PatchFilterKey = "PATCH_SET"
	PatchFilterKeyProduct        PatchFilterKey = "PRODUCT"
	PatchFilterKeyProductFamily  PatchFilterKey = "PRODUCT_FAMILY"
	PatchFilterKeyClassification PatchFilterKey = "CLASSIFICATION"
	PatchFilterKeyMsrcSeverity   PatchFilterKey = "MSRC_SEVERITY"
	PatchFilterKeyPatchId        PatchFilterKey = "PATCH_ID"
	PatchFilterKeySection        PatchFilterKey = "SECTION"
	PatchFilterKeyPriority       PatchFilterKey = "PRIORITY"
	PatchFilterKeySeverity       PatchFilterKey = "SEVERITY"
)

func (enum PatchFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PatchFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PatchOperationType string

// Enum values for PatchOperationType
const (
	PatchOperationTypeScan    PatchOperationType = "Scan"
	PatchOperationTypeInstall PatchOperationType = "Install"
)

func (enum PatchOperationType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PatchOperationType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PatchProperty string

// Enum values for PatchProperty
const (
	PatchPropertyProduct        PatchProperty = "PRODUCT"
	PatchPropertyProductFamily  PatchProperty = "PRODUCT_FAMILY"
	PatchPropertyClassification PatchProperty = "CLASSIFICATION"
	PatchPropertyMsrcSeverity   PatchProperty = "MSRC_SEVERITY"
	PatchPropertyPriority       PatchProperty = "PRIORITY"
	PatchPropertySeverity       PatchProperty = "SEVERITY"
)

func (enum PatchProperty) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PatchProperty) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PatchSet string

// Enum values for PatchSet
const (
	PatchSetOs          PatchSet = "OS"
	PatchSetApplication PatchSet = "APPLICATION"
)

func (enum PatchSet) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PatchSet) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PingStatus string

// Enum values for PingStatus
const (
	PingStatusOnline         PingStatus = "Online"
	PingStatusConnectionLost PingStatus = "ConnectionLost"
	PingStatusInactive       PingStatus = "Inactive"
)

func (enum PingStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PingStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type PlatformType string

// Enum values for PlatformType
const (
	PlatformTypeWindows PlatformType = "Windows"
	PlatformTypeLinux   PlatformType = "Linux"
)

func (enum PlatformType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PlatformType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type RebootOption string

// Enum values for RebootOption
const (
	RebootOptionRebootIfNeeded RebootOption = "RebootIfNeeded"
	RebootOptionNoReboot       RebootOption = "NoReboot"
)

func (enum RebootOption) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RebootOption) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ResourceDataSyncS3Format string

// Enum values for ResourceDataSyncS3Format
const (
	ResourceDataSyncS3FormatJsonSerDe ResourceDataSyncS3Format = "JsonSerDe"
)

func (enum ResourceDataSyncS3Format) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ResourceDataSyncS3Format) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ResourceType string

// Enum values for ResourceType
const (
	ResourceTypeManagedInstance ResourceType = "ManagedInstance"
	ResourceTypeDocument        ResourceType = "Document"
	ResourceTypeEc2instance     ResourceType = "EC2Instance"
)

func (enum ResourceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ResourceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ResourceTypeForTagging string

// Enum values for ResourceTypeForTagging
const (
	ResourceTypeForTaggingDocument          ResourceTypeForTagging = "Document"
	ResourceTypeForTaggingManagedInstance   ResourceTypeForTagging = "ManagedInstance"
	ResourceTypeForTaggingMaintenanceWindow ResourceTypeForTagging = "MaintenanceWindow"
	ResourceTypeForTaggingParameter         ResourceTypeForTagging = "Parameter"
	ResourceTypeForTaggingPatchBaseline     ResourceTypeForTagging = "PatchBaseline"
	ResourceTypeForTaggingOpsItem           ResourceTypeForTagging = "OpsItem"
)

func (enum ResourceTypeForTagging) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ResourceTypeForTagging) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SessionFilterKey string

// Enum values for SessionFilterKey
const (
	SessionFilterKeyInvokedAfter  SessionFilterKey = "InvokedAfter"
	SessionFilterKeyInvokedBefore SessionFilterKey = "InvokedBefore"
	SessionFilterKeyTarget        SessionFilterKey = "Target"
	SessionFilterKeyOwner         SessionFilterKey = "Owner"
	SessionFilterKeyStatus        SessionFilterKey = "Status"
)

func (enum SessionFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SessionFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SessionState string

// Enum values for SessionState
const (
	SessionStateActive  SessionState = "Active"
	SessionStateHistory SessionState = "History"
)

func (enum SessionState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SessionState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SessionStatus string

// Enum values for SessionStatus
const (
	SessionStatusConnected    SessionStatus = "Connected"
	SessionStatusConnecting   SessionStatus = "Connecting"
	SessionStatusDisconnected SessionStatus = "Disconnected"
	SessionStatusTerminated   SessionStatus = "Terminated"
	SessionStatusTerminating  SessionStatus = "Terminating"
	SessionStatusFailed       SessionStatus = "Failed"
)

func (enum SessionStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SessionStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SignalType string

// Enum values for SignalType
const (
	SignalTypeApprove   SignalType = "Approve"
	SignalTypeReject    SignalType = "Reject"
	SignalTypeStartStep SignalType = "StartStep"
	SignalTypeStopStep  SignalType = "StopStep"
	SignalTypeResume    SignalType = "Resume"
)

func (enum SignalType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SignalType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type StepExecutionFilterKey string

// Enum values for StepExecutionFilterKey
const (
	StepExecutionFilterKeyStartTimeBefore     StepExecutionFilterKey = "StartTimeBefore"
	StepExecutionFilterKeyStartTimeAfter      StepExecutionFilterKey = "StartTimeAfter"
	StepExecutionFilterKeyStepExecutionStatus StepExecutionFilterKey = "StepExecutionStatus"
	StepExecutionFilterKeyStepExecutionId     StepExecutionFilterKey = "StepExecutionId"
	StepExecutionFilterKeyStepName            StepExecutionFilterKey = "StepName"
	StepExecutionFilterKeyAction              StepExecutionFilterKey = "Action"
)

func (enum StepExecutionFilterKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum StepExecutionFilterKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type StopType string

// Enum values for StopType
const (
	StopTypeComplete StopType = "Complete"
	StopTypeCancel   StopType = "Cancel"
)

func (enum StopType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum StopType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}
