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

package lightsail

type AccessDirection string

// Enum values for AccessDirection
const (
	AccessDirectionInbound  AccessDirection = "inbound"
	AccessDirectionOutbound AccessDirection = "outbound"
)

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

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

type BlueprintType string

// Enum values for BlueprintType
const (
	BlueprintTypeOs  BlueprintType = "os"
	BlueprintTypeApp BlueprintType = "app"
)

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

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

type CloudFormationStackRecordSourceType string

// Enum values for CloudFormationStackRecordSourceType
const (
	CloudFormationStackRecordSourceTypeExportSnapshotRecord CloudFormationStackRecordSourceType = "ExportSnapshotRecord"
)

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

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

type DiskSnapshotState string

// Enum values for DiskSnapshotState
const (
	DiskSnapshotStatePending   DiskSnapshotState = "pending"
	DiskSnapshotStateCompleted DiskSnapshotState = "completed"
	DiskSnapshotStateError     DiskSnapshotState = "error"
	DiskSnapshotStateUnknown   DiskSnapshotState = "unknown"
)

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

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

type DiskState string

// Enum values for DiskState
const (
	DiskStatePending   DiskState = "pending"
	DiskStateError     DiskState = "error"
	DiskStateAvailable DiskState = "available"
	DiskStateInUse     DiskState = "in-use"
	DiskStateUnknown   DiskState = "unknown"
)

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

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

type ExportSnapshotRecordSourceType string

// Enum values for ExportSnapshotRecordSourceType
const (
	ExportSnapshotRecordSourceTypeInstanceSnapshot ExportSnapshotRecordSourceType = "InstanceSnapshot"
	ExportSnapshotRecordSourceTypeDiskSnapshot     ExportSnapshotRecordSourceType = "DiskSnapshot"
)

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

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

type InstanceAccessProtocol string

// Enum values for InstanceAccessProtocol
const (
	InstanceAccessProtocolSsh InstanceAccessProtocol = "ssh"
	InstanceAccessProtocolRdp InstanceAccessProtocol = "rdp"
)

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

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

type InstanceHealthReason string

// Enum values for InstanceHealthReason
const (
	InstanceHealthReasonLbRegistrationInProgress         InstanceHealthReason = "Lb.RegistrationInProgress"
	InstanceHealthReasonLbInitialHealthChecking          InstanceHealthReason = "Lb.InitialHealthChecking"
	InstanceHealthReasonLbInternalError                  InstanceHealthReason = "Lb.InternalError"
	InstanceHealthReasonInstanceResponseCodeMismatch     InstanceHealthReason = "Instance.ResponseCodeMismatch"
	InstanceHealthReasonInstanceTimeout                  InstanceHealthReason = "Instance.Timeout"
	InstanceHealthReasonInstanceFailedHealthChecks       InstanceHealthReason = "Instance.FailedHealthChecks"
	InstanceHealthReasonInstanceNotRegistered            InstanceHealthReason = "Instance.NotRegistered"
	InstanceHealthReasonInstanceNotInUse                 InstanceHealthReason = "Instance.NotInUse"
	InstanceHealthReasonInstanceDeregistrationInProgress InstanceHealthReason = "Instance.DeregistrationInProgress"
	InstanceHealthReasonInstanceInvalidState             InstanceHealthReason = "Instance.InvalidState"
	InstanceHealthReasonInstanceIpUnusable               InstanceHealthReason = "Instance.IpUnusable"
)

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

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

type InstanceHealthState string

// Enum values for InstanceHealthState
const (
	InstanceHealthStateInitial     InstanceHealthState = "initial"
	InstanceHealthStateHealthy     InstanceHealthState = "healthy"
	InstanceHealthStateUnhealthy   InstanceHealthState = "unhealthy"
	InstanceHealthStateUnused      InstanceHealthState = "unused"
	InstanceHealthStateDraining    InstanceHealthState = "draining"
	InstanceHealthStateUnavailable InstanceHealthState = "unavailable"
)

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

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

type InstanceMetricName string

// Enum values for InstanceMetricName
const (
	InstanceMetricNameCpuutilization            InstanceMetricName = "CPUUtilization"
	InstanceMetricNameNetworkIn                 InstanceMetricName = "NetworkIn"
	InstanceMetricNameNetworkOut                InstanceMetricName = "NetworkOut"
	InstanceMetricNameStatusCheckFailed         InstanceMetricName = "StatusCheckFailed"
	InstanceMetricNameStatusCheckFailedInstance InstanceMetricName = "StatusCheckFailed_Instance"
	InstanceMetricNameStatusCheckFailedSystem   InstanceMetricName = "StatusCheckFailed_System"
)

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

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

type InstancePlatform string

// Enum values for InstancePlatform
const (
	InstancePlatformLinuxUnix InstancePlatform = "LINUX_UNIX"
	InstancePlatformWindows   InstancePlatform = "WINDOWS"
)

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

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

type InstanceSnapshotState string

// Enum values for InstanceSnapshotState
const (
	InstanceSnapshotStatePending   InstanceSnapshotState = "pending"
	InstanceSnapshotStateError     InstanceSnapshotState = "error"
	InstanceSnapshotStateAvailable InstanceSnapshotState = "available"
)

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

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

type LoadBalancerAttributeName string

// Enum values for LoadBalancerAttributeName
const (
	LoadBalancerAttributeNameHealthCheckPath                          LoadBalancerAttributeName = "HealthCheckPath"
	LoadBalancerAttributeNameSessionStickinessEnabled                 LoadBalancerAttributeName = "SessionStickinessEnabled"
	LoadBalancerAttributeNameSessionStickinessLbCookieDurationSeconds LoadBalancerAttributeName = "SessionStickiness_LB_CookieDurationSeconds"
)

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

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

type LoadBalancerMetricName string

// Enum values for LoadBalancerMetricName
const (
	LoadBalancerMetricNameClientTlsnegotiationErrorCount LoadBalancerMetricName = "ClientTLSNegotiationErrorCount"
	LoadBalancerMetricNameHealthyHostCount               LoadBalancerMetricName = "HealthyHostCount"
	LoadBalancerMetricNameUnhealthyHostCount             LoadBalancerMetricName = "UnhealthyHostCount"
	LoadBalancerMetricNameHttpcodeLb4xxCount             LoadBalancerMetricName = "HTTPCode_LB_4XX_Count"
	LoadBalancerMetricNameHttpcodeLb5xxCount             LoadBalancerMetricName = "HTTPCode_LB_5XX_Count"
	LoadBalancerMetricNameHttpcodeInstance2xxCount       LoadBalancerMetricName = "HTTPCode_Instance_2XX_Count"
	LoadBalancerMetricNameHttpcodeInstance3xxCount       LoadBalancerMetricName = "HTTPCode_Instance_3XX_Count"
	LoadBalancerMetricNameHttpcodeInstance4xxCount       LoadBalancerMetricName = "HTTPCode_Instance_4XX_Count"
	LoadBalancerMetricNameHttpcodeInstance5xxCount       LoadBalancerMetricName = "HTTPCode_Instance_5XX_Count"
	LoadBalancerMetricNameInstanceResponseTime           LoadBalancerMetricName = "InstanceResponseTime"
	LoadBalancerMetricNameRejectedConnectionCount        LoadBalancerMetricName = "RejectedConnectionCount"
	LoadBalancerMetricNameRequestCount                   LoadBalancerMetricName = "RequestCount"
)

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

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

type LoadBalancerProtocol string

// Enum values for LoadBalancerProtocol
const (
	LoadBalancerProtocolHttpHttps LoadBalancerProtocol = "HTTP_HTTPS"
	LoadBalancerProtocolHttp      LoadBalancerProtocol = "HTTP"
)

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

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

type LoadBalancerState string

// Enum values for LoadBalancerState
const (
	LoadBalancerStateActive         LoadBalancerState = "active"
	LoadBalancerStateProvisioning   LoadBalancerState = "provisioning"
	LoadBalancerStateActiveImpaired LoadBalancerState = "active_impaired"
	LoadBalancerStateFailed         LoadBalancerState = "failed"
	LoadBalancerStateUnknown        LoadBalancerState = "unknown"
)

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

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

type LoadBalancerTlsCertificateDomainStatus string

// Enum values for LoadBalancerTlsCertificateDomainStatus
const (
	LoadBalancerTlsCertificateDomainStatusPendingValidation LoadBalancerTlsCertificateDomainStatus = "PENDING_VALIDATION"
	LoadBalancerTlsCertificateDomainStatusFailed            LoadBalancerTlsCertificateDomainStatus = "FAILED"
	LoadBalancerTlsCertificateDomainStatusSuccess           LoadBalancerTlsCertificateDomainStatus = "SUCCESS"
)

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

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

type LoadBalancerTlsCertificateFailureReason string

// Enum values for LoadBalancerTlsCertificateFailureReason
const (
	LoadBalancerTlsCertificateFailureReasonNoAvailableContacts            LoadBalancerTlsCertificateFailureReason = "NO_AVAILABLE_CONTACTS"
	LoadBalancerTlsCertificateFailureReasonAdditionalVerificationRequired LoadBalancerTlsCertificateFailureReason = "ADDITIONAL_VERIFICATION_REQUIRED"
	LoadBalancerTlsCertificateFailureReasonDomainNotAllowed               LoadBalancerTlsCertificateFailureReason = "DOMAIN_NOT_ALLOWED"
	LoadBalancerTlsCertificateFailureReasonInvalidPublicDomain            LoadBalancerTlsCertificateFailureReason = "INVALID_PUBLIC_DOMAIN"
	LoadBalancerTlsCertificateFailureReasonOther                          LoadBalancerTlsCertificateFailureReason = "OTHER"
)

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

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

type LoadBalancerTlsCertificateRenewalStatus string

// Enum values for LoadBalancerTlsCertificateRenewalStatus
const (
	LoadBalancerTlsCertificateRenewalStatusPendingAutoRenewal LoadBalancerTlsCertificateRenewalStatus = "PENDING_AUTO_RENEWAL"
	LoadBalancerTlsCertificateRenewalStatusPendingValidation  LoadBalancerTlsCertificateRenewalStatus = "PENDING_VALIDATION"
	LoadBalancerTlsCertificateRenewalStatusSuccess            LoadBalancerTlsCertificateRenewalStatus = "SUCCESS"
	LoadBalancerTlsCertificateRenewalStatusFailed             LoadBalancerTlsCertificateRenewalStatus = "FAILED"
)

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

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

type LoadBalancerTlsCertificateRevocationReason string

// Enum values for LoadBalancerTlsCertificateRevocationReason
const (
	LoadBalancerTlsCertificateRevocationReasonUnspecified          LoadBalancerTlsCertificateRevocationReason = "UNSPECIFIED"
	LoadBalancerTlsCertificateRevocationReasonKeyCompromise        LoadBalancerTlsCertificateRevocationReason = "KEY_COMPROMISE"
	LoadBalancerTlsCertificateRevocationReasonCaCompromise         LoadBalancerTlsCertificateRevocationReason = "CA_COMPROMISE"
	LoadBalancerTlsCertificateRevocationReasonAffiliationChanged   LoadBalancerTlsCertificateRevocationReason = "AFFILIATION_CHANGED"
	LoadBalancerTlsCertificateRevocationReasonSuperceded           LoadBalancerTlsCertificateRevocationReason = "SUPERCEDED"
	LoadBalancerTlsCertificateRevocationReasonCessationOfOperation LoadBalancerTlsCertificateRevocationReason = "CESSATION_OF_OPERATION"
	LoadBalancerTlsCertificateRevocationReasonCertificateHold      LoadBalancerTlsCertificateRevocationReason = "CERTIFICATE_HOLD"
	LoadBalancerTlsCertificateRevocationReasonRemoveFromCrl        LoadBalancerTlsCertificateRevocationReason = "REMOVE_FROM_CRL"
	LoadBalancerTlsCertificateRevocationReasonPrivilegeWithdrawn   LoadBalancerTlsCertificateRevocationReason = "PRIVILEGE_WITHDRAWN"
	LoadBalancerTlsCertificateRevocationReasonAACompromise         LoadBalancerTlsCertificateRevocationReason = "A_A_COMPROMISE"
)

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

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

type LoadBalancerTlsCertificateStatus string

// Enum values for LoadBalancerTlsCertificateStatus
const (
	LoadBalancerTlsCertificateStatusPendingValidation  LoadBalancerTlsCertificateStatus = "PENDING_VALIDATION"
	LoadBalancerTlsCertificateStatusIssued             LoadBalancerTlsCertificateStatus = "ISSUED"
	LoadBalancerTlsCertificateStatusInactive           LoadBalancerTlsCertificateStatus = "INACTIVE"
	LoadBalancerTlsCertificateStatusExpired            LoadBalancerTlsCertificateStatus = "EXPIRED"
	LoadBalancerTlsCertificateStatusValidationTimedOut LoadBalancerTlsCertificateStatus = "VALIDATION_TIMED_OUT"
	LoadBalancerTlsCertificateStatusRevoked            LoadBalancerTlsCertificateStatus = "REVOKED"
	LoadBalancerTlsCertificateStatusFailed             LoadBalancerTlsCertificateStatus = "FAILED"
	LoadBalancerTlsCertificateStatusUnknown            LoadBalancerTlsCertificateStatus = "UNKNOWN"
)

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

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

type MetricStatistic string

// Enum values for MetricStatistic
const (
	MetricStatisticMinimum     MetricStatistic = "Minimum"
	MetricStatisticMaximum     MetricStatistic = "Maximum"
	MetricStatisticSum         MetricStatistic = "Sum"
	MetricStatisticAverage     MetricStatistic = "Average"
	MetricStatisticSampleCount MetricStatistic = "SampleCount"
)

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

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

type MetricUnit string

// Enum values for MetricUnit
const (
	MetricUnitSeconds         MetricUnit = "Seconds"
	MetricUnitMicroseconds    MetricUnit = "Microseconds"
	MetricUnitMilliseconds    MetricUnit = "Milliseconds"
	MetricUnitBytes           MetricUnit = "Bytes"
	MetricUnitKilobytes       MetricUnit = "Kilobytes"
	MetricUnitMegabytes       MetricUnit = "Megabytes"
	MetricUnitGigabytes       MetricUnit = "Gigabytes"
	MetricUnitTerabytes       MetricUnit = "Terabytes"
	MetricUnitBits            MetricUnit = "Bits"
	MetricUnitKilobits        MetricUnit = "Kilobits"
	MetricUnitMegabits        MetricUnit = "Megabits"
	MetricUnitGigabits        MetricUnit = "Gigabits"
	MetricUnitTerabits        MetricUnit = "Terabits"
	MetricUnitPercent         MetricUnit = "Percent"
	MetricUnitCount           MetricUnit = "Count"
	MetricUnitBytesSecond     MetricUnit = "Bytes/Second"
	MetricUnitKilobytesSecond MetricUnit = "Kilobytes/Second"
	MetricUnitMegabytesSecond MetricUnit = "Megabytes/Second"
	MetricUnitGigabytesSecond MetricUnit = "Gigabytes/Second"
	MetricUnitTerabytesSecond MetricUnit = "Terabytes/Second"
	MetricUnitBitsSecond      MetricUnit = "Bits/Second"
	MetricUnitKilobitsSecond  MetricUnit = "Kilobits/Second"
	MetricUnitMegabitsSecond  MetricUnit = "Megabits/Second"
	MetricUnitGigabitsSecond  MetricUnit = "Gigabits/Second"
	MetricUnitTerabitsSecond  MetricUnit = "Terabits/Second"
	MetricUnitCountSecond     MetricUnit = "Count/Second"
	MetricUnitNone            MetricUnit = "None"
)

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

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

type NetworkProtocol string

// Enum values for NetworkProtocol
const (
	NetworkProtocolTcp NetworkProtocol = "tcp"
	NetworkProtocolAll NetworkProtocol = "all"
	NetworkProtocolUdp NetworkProtocol = "udp"
)

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

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

type OperationStatus string

// Enum values for OperationStatus
const (
	OperationStatusNotStarted OperationStatus = "NotStarted"
	OperationStatusStarted    OperationStatus = "Started"
	OperationStatusFailed     OperationStatus = "Failed"
	OperationStatusCompleted  OperationStatus = "Completed"
	OperationStatusSucceeded  OperationStatus = "Succeeded"
)

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

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

type OperationType string

// Enum values for OperationType
const (
	OperationTypeDeleteKnownHostKeys                  OperationType = "DeleteKnownHostKeys"
	OperationTypeDeleteInstance                       OperationType = "DeleteInstance"
	OperationTypeCreateInstance                       OperationType = "CreateInstance"
	OperationTypeStopInstance                         OperationType = "StopInstance"
	OperationTypeStartInstance                        OperationType = "StartInstance"
	OperationTypeRebootInstance                       OperationType = "RebootInstance"
	OperationTypeOpenInstancePublicPorts              OperationType = "OpenInstancePublicPorts"
	OperationTypePutInstancePublicPorts               OperationType = "PutInstancePublicPorts"
	OperationTypeCloseInstancePublicPorts             OperationType = "CloseInstancePublicPorts"
	OperationTypeAllocateStaticIp                     OperationType = "AllocateStaticIp"
	OperationTypeReleaseStaticIp                      OperationType = "ReleaseStaticIp"
	OperationTypeAttachStaticIp                       OperationType = "AttachStaticIp"
	OperationTypeDetachStaticIp                       OperationType = "DetachStaticIp"
	OperationTypeUpdateDomainEntry                    OperationType = "UpdateDomainEntry"
	OperationTypeDeleteDomainEntry                    OperationType = "DeleteDomainEntry"
	OperationTypeCreateDomain                         OperationType = "CreateDomain"
	OperationTypeDeleteDomain                         OperationType = "DeleteDomain"
	OperationTypeCreateInstanceSnapshot               OperationType = "CreateInstanceSnapshot"
	OperationTypeDeleteInstanceSnapshot               OperationType = "DeleteInstanceSnapshot"
	OperationTypeCreateInstancesFromSnapshot          OperationType = "CreateInstancesFromSnapshot"
	OperationTypeCreateLoadBalancer                   OperationType = "CreateLoadBalancer"
	OperationTypeDeleteLoadBalancer                   OperationType = "DeleteLoadBalancer"
	OperationTypeAttachInstancesToLoadBalancer        OperationType = "AttachInstancesToLoadBalancer"
	OperationTypeDetachInstancesFromLoadBalancer      OperationType = "DetachInstancesFromLoadBalancer"
	OperationTypeUpdateLoadBalancerAttribute          OperationType = "UpdateLoadBalancerAttribute"
	OperationTypeCreateLoadBalancerTlsCertificate     OperationType = "CreateLoadBalancerTlsCertificate"
	OperationTypeDeleteLoadBalancerTlsCertificate     OperationType = "DeleteLoadBalancerTlsCertificate"
	OperationTypeAttachLoadBalancerTlsCertificate     OperationType = "AttachLoadBalancerTlsCertificate"
	OperationTypeCreateDisk                           OperationType = "CreateDisk"
	OperationTypeDeleteDisk                           OperationType = "DeleteDisk"
	OperationTypeAttachDisk                           OperationType = "AttachDisk"
	OperationTypeDetachDisk                           OperationType = "DetachDisk"
	OperationTypeCreateDiskSnapshot                   OperationType = "CreateDiskSnapshot"
	OperationTypeDeleteDiskSnapshot                   OperationType = "DeleteDiskSnapshot"
	OperationTypeCreateDiskFromSnapshot               OperationType = "CreateDiskFromSnapshot"
	OperationTypeCreateRelationalDatabase             OperationType = "CreateRelationalDatabase"
	OperationTypeUpdateRelationalDatabase             OperationType = "UpdateRelationalDatabase"
	OperationTypeDeleteRelationalDatabase             OperationType = "DeleteRelationalDatabase"
	OperationTypeCreateRelationalDatabaseFromSnapshot OperationType = "CreateRelationalDatabaseFromSnapshot"
	OperationTypeCreateRelationalDatabaseSnapshot     OperationType = "CreateRelationalDatabaseSnapshot"
	OperationTypeDeleteRelationalDatabaseSnapshot     OperationType = "DeleteRelationalDatabaseSnapshot"
	OperationTypeUpdateRelationalDatabaseParameters   OperationType = "UpdateRelationalDatabaseParameters"
	OperationTypeStartRelationalDatabase              OperationType = "StartRelationalDatabase"
	OperationTypeRebootRelationalDatabase             OperationType = "RebootRelationalDatabase"
	OperationTypeStopRelationalDatabase               OperationType = "StopRelationalDatabase"
)

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

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

type PortAccessType string

// Enum values for PortAccessType
const (
	PortAccessTypePublic  PortAccessType = "Public"
	PortAccessTypePrivate PortAccessType = "Private"
)

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

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

type PortInfoSourceType string

// Enum values for PortInfoSourceType
const (
	PortInfoSourceTypeDefault  PortInfoSourceType = "DEFAULT"
	PortInfoSourceTypeInstance PortInfoSourceType = "INSTANCE"
	PortInfoSourceTypeNone     PortInfoSourceType = "NONE"
	PortInfoSourceTypeClosed   PortInfoSourceType = "CLOSED"
)

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

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

type PortState string

// Enum values for PortState
const (
	PortStateOpen   PortState = "open"
	PortStateClosed PortState = "closed"
)

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

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

type RecordState string

// Enum values for RecordState
const (
	RecordStateStarted   RecordState = "Started"
	RecordStateSucceeded RecordState = "Succeeded"
	RecordStateFailed    RecordState = "Failed"
)

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

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

type RegionName string

// Enum values for RegionName
const (
	RegionNameUsEast1      RegionName = "us-east-1"
	RegionNameUsEast2      RegionName = "us-east-2"
	RegionNameUsWest1      RegionName = "us-west-1"
	RegionNameUsWest2      RegionName = "us-west-2"
	RegionNameEuWest1      RegionName = "eu-west-1"
	RegionNameEuWest2      RegionName = "eu-west-2"
	RegionNameEuWest3      RegionName = "eu-west-3"
	RegionNameEuCentral1   RegionName = "eu-central-1"
	RegionNameCaCentral1   RegionName = "ca-central-1"
	RegionNameApSouth1     RegionName = "ap-south-1"
	RegionNameApSoutheast1 RegionName = "ap-southeast-1"
	RegionNameApSoutheast2 RegionName = "ap-southeast-2"
	RegionNameApNortheast1 RegionName = "ap-northeast-1"
	RegionNameApNortheast2 RegionName = "ap-northeast-2"
)

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

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

type RelationalDatabaseEngine string

// Enum values for RelationalDatabaseEngine
const (
	RelationalDatabaseEngineMysql RelationalDatabaseEngine = "mysql"
)

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

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

type RelationalDatabaseMetricName string

// Enum values for RelationalDatabaseMetricName
const (
	RelationalDatabaseMetricNameCpuutilization            RelationalDatabaseMetricName = "CPUUtilization"
	RelationalDatabaseMetricNameDatabaseConnections       RelationalDatabaseMetricName = "DatabaseConnections"
	RelationalDatabaseMetricNameDiskQueueDepth            RelationalDatabaseMetricName = "DiskQueueDepth"
	RelationalDatabaseMetricNameFreeStorageSpace          RelationalDatabaseMetricName = "FreeStorageSpace"
	RelationalDatabaseMetricNameNetworkReceiveThroughput  RelationalDatabaseMetricName = "NetworkReceiveThroughput"
	RelationalDatabaseMetricNameNetworkTransmitThroughput RelationalDatabaseMetricName = "NetworkTransmitThroughput"
)

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

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

type RelationalDatabasePasswordVersion string

// Enum values for RelationalDatabasePasswordVersion
const (
	RelationalDatabasePasswordVersionCurrent  RelationalDatabasePasswordVersion = "CURRENT"
	RelationalDatabasePasswordVersionPrevious RelationalDatabasePasswordVersion = "PREVIOUS"
	RelationalDatabasePasswordVersionPending  RelationalDatabasePasswordVersion = "PENDING"
)

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

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

type ResourceType string

// Enum values for ResourceType
const (
	ResourceTypeInstance                   ResourceType = "Instance"
	ResourceTypeStaticIp                   ResourceType = "StaticIp"
	ResourceTypeKeyPair                    ResourceType = "KeyPair"
	ResourceTypeInstanceSnapshot           ResourceType = "InstanceSnapshot"
	ResourceTypeDomain                     ResourceType = "Domain"
	ResourceTypePeeredVpc                  ResourceType = "PeeredVpc"
	ResourceTypeLoadBalancer               ResourceType = "LoadBalancer"
	ResourceTypeLoadBalancerTlsCertificate ResourceType = "LoadBalancerTlsCertificate"
	ResourceTypeDisk                       ResourceType = "Disk"
	ResourceTypeDiskSnapshot               ResourceType = "DiskSnapshot"
	ResourceTypeRelationalDatabase         ResourceType = "RelationalDatabase"
	ResourceTypeRelationalDatabaseSnapshot ResourceType = "RelationalDatabaseSnapshot"
	ResourceTypeExportSnapshotRecord       ResourceType = "ExportSnapshotRecord"
	ResourceTypeCloudFormationStackRecord  ResourceType = "CloudFormationStackRecord"
)

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
}
