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

package types

import (
	"github.com/aws/aws-sdk-go-v2/service/computeoptimizer/schemas"
	smithy "github.com/aws/smithy-go"
	smithydocument "github.com/aws/smithy-go/document"
	"time"
)

// Describes the enrollment status of an organization's member accounts in Compute
// Optimizer.
type AccountEnrollmentStatus struct {

	// The Amazon Web Services account ID.
	AccountId *string

	// The Unix epoch timestamp, in seconds, of when the account enrollment status was
	// last updated.
	LastUpdatedTimestamp *time.Time

	// The account enrollment status.
	Status Status

	// The reason for the account enrollment status.
	//
	// For example, an account might show a status of Pending because member accounts
	// of an organization require more time to be enrolled in the service.
	StatusReason *string

	noSmithyDocumentSerde
}

func (v *AccountEnrollmentStatus) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.AccountEnrollmentStatus)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *AccountEnrollmentStatus) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.AccountEnrollmentStatus_accountId, *v.AccountId)
	}
	if v.LastUpdatedTimestamp != nil {
		s.WriteTime(schemas.AccountEnrollmentStatus_lastUpdatedTimestamp, *v.LastUpdatedTimestamp)
	}
	if v.Status != "" {
		s.WriteString(schemas.AccountEnrollmentStatus_status, string(v.Status))
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.AccountEnrollmentStatus_statusReason, *v.StatusReason)
	}
}
func (v *AccountEnrollmentStatus) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AccountEnrollmentStatus, func(s *smithy.Schema) error {
		switch s {
		case schemas.AccountEnrollmentStatus_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.AccountEnrollmentStatus_accountId, v.AccountId)
		case schemas.AccountEnrollmentStatus_lastUpdatedTimestamp:
			v.LastUpdatedTimestamp = new(time.Time)
			return d.ReadTime(schemas.AccountEnrollmentStatus_lastUpdatedTimestamp, v.LastUpdatedTimestamp)
		case schemas.AccountEnrollmentStatus_status:
			var ev string
			if err := d.ReadString(schemas.AccountEnrollmentStatus_status, &ev); err != nil {
				return err
			}
			v.Status = Status(ev)
			return nil
		case schemas.AccountEnrollmentStatus_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.AccountEnrollmentStatus_statusReason, v.StatusReason)
		}
		return nil
	})
}

// Describes the configuration of an EC2 Auto Scaling group.
type AutoScalingGroupConfiguration struct {

	//  Describes the allocation strategy that the EC2 Auto Scaling group uses. This
	// field is only available for EC2 Auto Scaling groups with mixed instance types.
	AllocationStrategy AllocationStrategy

	// The desired capacity, or number of instances, for the EC2 Auto Scaling group.
	DesiredCapacity int32

	//  Describes the projected percentage reduction in instance hours after adopting
	// the recommended configuration. This field is only available for EC2 Auto Scaling
	// groups with scaling policies.
	EstimatedInstanceHourReductionPercentage *float64

	// The instance type for the EC2 Auto Scaling group.
	InstanceType *string

	// The maximum size, or maximum number of instances, for the EC2 Auto Scaling
	// group.
	MaxSize int32

	// The minimum size, or minimum number of instances, for the EC2 Auto Scaling
	// group.
	MinSize int32

	//  List the instance types within an EC2 Auto Scaling group that has mixed
	// instance types.
	MixedInstanceTypes []string

	//  Describes whether the EC2 Auto Scaling group has a single instance type or a
	// mixed instance type configuration.
	Type AsgType

	noSmithyDocumentSerde
}

func (v *AutoScalingGroupConfiguration) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.AutoScalingGroupConfiguration)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *AutoScalingGroupConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AllocationStrategy != "" {
		s.WriteString(schemas.AutoScalingGroupConfiguration_allocationStrategy, string(v.AllocationStrategy))
	}
	if v.DesiredCapacity != 0 {
		s.WriteInt32(schemas.AutoScalingGroupConfiguration_desiredCapacity, v.DesiredCapacity)
	}
	if v.EstimatedInstanceHourReductionPercentage != nil {
		s.WriteFloat64(schemas.AutoScalingGroupConfiguration_estimatedInstanceHourReductionPercentage, *v.EstimatedInstanceHourReductionPercentage)
	}
	if v.InstanceType != nil {
		s.WriteString(schemas.AutoScalingGroupConfiguration_instanceType, *v.InstanceType)
	}
	if v.MaxSize != 0 {
		s.WriteInt32(schemas.AutoScalingGroupConfiguration_maxSize, v.MaxSize)
	}
	if v.MinSize != 0 {
		s.WriteInt32(schemas.AutoScalingGroupConfiguration_minSize, v.MinSize)
	}
	serializeMixedInstanceTypes(s, schemas.AutoScalingGroupConfiguration_mixedInstanceTypes, v.MixedInstanceTypes)
	if v.Type != "" {
		s.WriteString(schemas.AutoScalingGroupConfiguration_type, string(v.Type))
	}
}
func (v *AutoScalingGroupConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AutoScalingGroupConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.AutoScalingGroupConfiguration_allocationStrategy:
			var ev string
			if err := d.ReadString(schemas.AutoScalingGroupConfiguration_allocationStrategy, &ev); err != nil {
				return err
			}
			v.AllocationStrategy = AllocationStrategy(ev)
			return nil
		case schemas.AutoScalingGroupConfiguration_desiredCapacity:
			return d.ReadInt32(schemas.AutoScalingGroupConfiguration_desiredCapacity, &v.DesiredCapacity)
		case schemas.AutoScalingGroupConfiguration_estimatedInstanceHourReductionPercentage:
			v.EstimatedInstanceHourReductionPercentage = new(float64)
			return d.ReadFloat64(schemas.AutoScalingGroupConfiguration_estimatedInstanceHourReductionPercentage, v.EstimatedInstanceHourReductionPercentage)
		case schemas.AutoScalingGroupConfiguration_instanceType:
			v.InstanceType = new(string)
			return d.ReadString(schemas.AutoScalingGroupConfiguration_instanceType, v.InstanceType)
		case schemas.AutoScalingGroupConfiguration_maxSize:
			return d.ReadInt32(schemas.AutoScalingGroupConfiguration_maxSize, &v.MaxSize)
		case schemas.AutoScalingGroupConfiguration_minSize:
			return d.ReadInt32(schemas.AutoScalingGroupConfiguration_minSize, &v.MinSize)
		case schemas.AutoScalingGroupConfiguration_mixedInstanceTypes:
			return deserializeMixedInstanceTypes(d, schemas.AutoScalingGroupConfiguration_mixedInstanceTypes, &v.MixedInstanceTypes)
		case schemas.AutoScalingGroupConfiguration_type:
			var ev string
			if err := d.ReadString(schemas.AutoScalingGroupConfiguration_type, &ev); err != nil {
				return err
			}
			v.Type = AsgType(ev)
			return nil
		}
		return nil
	})
}

//	An object that describes the estimated monthly savings possible by adopting
//
// Compute Optimizer’s Auto Scaling group recommendations. This is based on the
// Savings Plans and Reserved Instances discounts.
type AutoScalingGroupEstimatedMonthlySavings struct {

	//  The currency of the estimated monthly savings.
	Currency Currency

	//  The value of the estimated monthly savings.
	Value float64

	noSmithyDocumentSerde
}

func (v *AutoScalingGroupEstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.AutoScalingGroupEstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *AutoScalingGroupEstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.AutoScalingGroupEstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.AutoScalingGroupEstimatedMonthlySavings_value, v.Value)
	}
}
func (v *AutoScalingGroupEstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AutoScalingGroupEstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.AutoScalingGroupEstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.AutoScalingGroupEstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.AutoScalingGroupEstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.AutoScalingGroupEstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

// Describes an Auto Scaling group recommendation.
type AutoScalingGroupRecommendation struct {

	// The Amazon Web Services account ID of the Auto Scaling group.
	AccountId *string

	// The Amazon Resource Name (ARN) of the Auto Scaling group.
	AutoScalingGroupArn *string

	// The name of the Auto Scaling group.
	AutoScalingGroupName *string

	// An array of objects that describe the current configuration of the Auto Scaling
	// group.
	CurrentConfiguration *AutoScalingGroupConfiguration

	//  Describes the GPU accelerator settings for the current instance type of the
	// Auto Scaling group.
	CurrentInstanceGpuInfo *GpuInfo

	// The risk of the current Auto Scaling group not meeting the performance needs of
	// its workloads. The higher the risk, the more likely the current Auto Scaling
	// group configuration has insufficient capacity and cannot meet workload
	// requirements.
	CurrentPerformanceRisk CurrentPerformanceRisk

	// An object that describes the effective recommendation preferences for the Auto
	// Scaling group.
	EffectiveRecommendationPreferences *EffectiveRecommendationPreferences

	// The finding classification of the Auto Scaling group.
	//
	// Findings for Auto Scaling groups include:
	//
	//   - NotOptimized —An Auto Scaling group is considered not optimized when Compute
	//   Optimizer identifies a recommendation that can provide better performance for
	//   your workload.
	//
	//   - Optimized —An Auto Scaling group is considered optimized when Compute
	//   Optimizer determines that the group is correctly provisioned to run your
	//   workload based on the chosen instance type. For optimized resources, Compute
	//   Optimizer might recommend a new generation instance type.
	Finding Finding

	// The applications that might be running on the instances in the Auto Scaling
	// group as inferred by Compute Optimizer.
	//
	// Compute Optimizer can infer if one of the following applications might be
	// running on the instances:
	//
	//   - AmazonEmr - Infers that Amazon EMR might be running on the instances.
	//
	//   - ApacheCassandra - Infers that Apache Cassandra might be running on the
	//   instances.
	//
	//   - ApacheHadoop - Infers that Apache Hadoop might be running on the instances.
	//
	//   - Memcached - Infers that Memcached might be running on the instances.
	//
	//   - NGINX - Infers that NGINX might be running on the instances.
	//
	//   - PostgreSql - Infers that PostgreSQL might be running on the instances.
	//
	//   - Redis - Infers that Redis might be running on the instances.
	//
	//   - Kafka - Infers that Kafka might be running on the instance.
	//
	//   - SQLServer - Infers that SQLServer might be running on the instance.
	InferredWorkloadTypes []InferredWorkloadType

	// The timestamp of when the Auto Scaling group recommendation was last generated.
	LastRefreshTimestamp *time.Time

	// The number of days for which utilization metrics were analyzed for the Auto
	// Scaling group.
	LookBackPeriodInDays float64

	// An array of objects that describe the recommendation options for the Auto
	// Scaling group.
	RecommendationOptions []AutoScalingGroupRecommendationOption

	// An array of objects that describe the utilization metrics of the Auto Scaling
	// group.
	UtilizationMetrics []UtilizationMetric

	noSmithyDocumentSerde
}

func (v *AutoScalingGroupRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.AutoScalingGroupRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *AutoScalingGroupRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.AutoScalingGroupRecommendation_accountId, *v.AccountId)
	}
	if v.AutoScalingGroupArn != nil {
		s.WriteString(schemas.AutoScalingGroupRecommendation_autoScalingGroupArn, *v.AutoScalingGroupArn)
	}
	if v.AutoScalingGroupName != nil {
		s.WriteString(schemas.AutoScalingGroupRecommendation_autoScalingGroupName, *v.AutoScalingGroupName)
	}
	if v.CurrentConfiguration != nil {
		s.WriteStruct(schemas.AutoScalingGroupRecommendation_currentConfiguration)
		v.CurrentConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CurrentInstanceGpuInfo != nil {
		s.WriteStruct(schemas.AutoScalingGroupRecommendation_currentInstanceGpuInfo)
		v.CurrentInstanceGpuInfo.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CurrentPerformanceRisk != "" {
		s.WriteString(schemas.AutoScalingGroupRecommendation_currentPerformanceRisk, string(v.CurrentPerformanceRisk))
	}
	if v.EffectiveRecommendationPreferences != nil {
		s.WriteStruct(schemas.AutoScalingGroupRecommendation_effectiveRecommendationPreferences)
		v.EffectiveRecommendationPreferences.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Finding != "" {
		s.WriteString(schemas.AutoScalingGroupRecommendation_finding, string(v.Finding))
	}
	serializeInferredWorkloadTypes(s, schemas.AutoScalingGroupRecommendation_inferredWorkloadTypes, v.InferredWorkloadTypes)
	if v.LastRefreshTimestamp != nil {
		s.WriteTime(schemas.AutoScalingGroupRecommendation_lastRefreshTimestamp, *v.LastRefreshTimestamp)
	}
	if v.LookBackPeriodInDays != 0 {
		s.WriteFloat64(schemas.AutoScalingGroupRecommendation_lookBackPeriodInDays, v.LookBackPeriodInDays)
	}
	serializeAutoScalingGroupRecommendationOptions(s, schemas.AutoScalingGroupRecommendation_recommendationOptions, v.RecommendationOptions)
	serializeUtilizationMetrics(s, schemas.AutoScalingGroupRecommendation_utilizationMetrics, v.UtilizationMetrics)
}
func (v *AutoScalingGroupRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AutoScalingGroupRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.AutoScalingGroupRecommendation_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.AutoScalingGroupRecommendation_accountId, v.AccountId)
		case schemas.AutoScalingGroupRecommendation_autoScalingGroupArn:
			v.AutoScalingGroupArn = new(string)
			return d.ReadString(schemas.AutoScalingGroupRecommendation_autoScalingGroupArn, v.AutoScalingGroupArn)
		case schemas.AutoScalingGroupRecommendation_autoScalingGroupName:
			v.AutoScalingGroupName = new(string)
			return d.ReadString(schemas.AutoScalingGroupRecommendation_autoScalingGroupName, v.AutoScalingGroupName)
		case schemas.AutoScalingGroupRecommendation_currentConfiguration:
			v.CurrentConfiguration = &AutoScalingGroupConfiguration{}
			return v.CurrentConfiguration.Deserialize(d)
		case schemas.AutoScalingGroupRecommendation_currentInstanceGpuInfo:
			v.CurrentInstanceGpuInfo = &GpuInfo{}
			return v.CurrentInstanceGpuInfo.Deserialize(d)
		case schemas.AutoScalingGroupRecommendation_currentPerformanceRisk:
			var ev string
			if err := d.ReadString(schemas.AutoScalingGroupRecommendation_currentPerformanceRisk, &ev); err != nil {
				return err
			}
			v.CurrentPerformanceRisk = CurrentPerformanceRisk(ev)
			return nil
		case schemas.AutoScalingGroupRecommendation_effectiveRecommendationPreferences:
			v.EffectiveRecommendationPreferences = &EffectiveRecommendationPreferences{}
			return v.EffectiveRecommendationPreferences.Deserialize(d)
		case schemas.AutoScalingGroupRecommendation_finding:
			var ev string
			if err := d.ReadString(schemas.AutoScalingGroupRecommendation_finding, &ev); err != nil {
				return err
			}
			v.Finding = Finding(ev)
			return nil
		case schemas.AutoScalingGroupRecommendation_inferredWorkloadTypes:
			return deserializeInferredWorkloadTypes(d, schemas.AutoScalingGroupRecommendation_inferredWorkloadTypes, &v.InferredWorkloadTypes)
		case schemas.AutoScalingGroupRecommendation_lastRefreshTimestamp:
			v.LastRefreshTimestamp = new(time.Time)
			return d.ReadTime(schemas.AutoScalingGroupRecommendation_lastRefreshTimestamp, v.LastRefreshTimestamp)
		case schemas.AutoScalingGroupRecommendation_lookBackPeriodInDays:
			return d.ReadFloat64(schemas.AutoScalingGroupRecommendation_lookBackPeriodInDays, &v.LookBackPeriodInDays)
		case schemas.AutoScalingGroupRecommendation_recommendationOptions:
			return deserializeAutoScalingGroupRecommendationOptions(d, schemas.AutoScalingGroupRecommendation_recommendationOptions, &v.RecommendationOptions)
		case schemas.AutoScalingGroupRecommendation_utilizationMetrics:
			return deserializeUtilizationMetrics(d, schemas.AutoScalingGroupRecommendation_utilizationMetrics, &v.UtilizationMetrics)
		}
		return nil
	})
}

// Describes a recommendation option for an Auto Scaling group.
type AutoScalingGroupRecommendationOption struct {

	// An array of objects that describe an Auto Scaling group configuration.
	Configuration *AutoScalingGroupConfiguration

	//  Describes the GPU accelerator settings for the recommended instance type of
	// the Auto Scaling group.
	InstanceGpuInfo *GpuInfo

	// The level of effort required to migrate from the current instance type to the
	// recommended instance type.
	//
	// For example, the migration effort is Low if Amazon EMR is the inferred workload
	// type and an Amazon Web Services Graviton instance type is recommended. The
	// migration effort is Medium if a workload type couldn't be inferred but an
	// Amazon Web Services Graviton instance type is recommended. The migration effort
	// is VeryLow if both the current and recommended instance types are of the same
	// CPU architecture.
	MigrationEffort MigrationEffort

	// The performance risk of the Auto Scaling group configuration recommendation.
	//
	// Performance risk indicates the likelihood of the recommended instance type not
	// meeting the resource needs of your workload. Compute Optimizer calculates an
	// individual performance risk score for each specification of the recommended
	// instance, including CPU, memory, EBS throughput, EBS IOPS, disk throughput, disk
	// IOPS, network throughput, and network PPS. The performance risk of the
	// recommended instance is calculated as the maximum performance risk score across
	// the analyzed resource specifications.
	//
	// The value ranges from 0 - 4 , with 0 meaning that the recommended resource is
	// predicted to always provide enough hardware capability. The higher the
	// performance risk is, the more likely you should validate whether the
	// recommendation will meet the performance requirements of your workload before
	// migrating your resource.
	PerformanceRisk float64

	// An array of objects that describe the projected utilization metrics of the Auto
	// Scaling group recommendation option.
	//
	// The Cpu and Memory metrics are the only projected utilization metrics returned.
	// Additionally, the Memory metric is returned only for resources that have the
	// unified CloudWatch agent installed on them. For more information, see [Enabling Memory Utilization with the CloudWatch Agent].
	//
	// [Enabling Memory Utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#cw-agent
	ProjectedUtilizationMetrics []UtilizationMetric

	// The rank of the Auto Scaling group recommendation option.
	//
	// The top recommendation option is ranked as 1 .
	Rank int32

	// An object that describes the savings opportunity for the Auto Scaling group
	// recommendation option. Savings opportunity includes the estimated monthly
	// savings amount and percentage.
	SavingsOpportunity *SavingsOpportunity

	//  An object that describes the savings opportunity for the Auto Scaling group
	// recommendation option that includes Savings Plans and Reserved Instances
	// discounts. Savings opportunity includes the estimated monthly savings and
	// percentage.
	SavingsOpportunityAfterDiscounts *AutoScalingGroupSavingsOpportunityAfterDiscounts

	noSmithyDocumentSerde
}

func (v *AutoScalingGroupRecommendationOption) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.AutoScalingGroupRecommendationOption)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *AutoScalingGroupRecommendationOption) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Configuration != nil {
		s.WriteStruct(schemas.AutoScalingGroupRecommendationOption_configuration)
		v.Configuration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.InstanceGpuInfo != nil {
		s.WriteStruct(schemas.AutoScalingGroupRecommendationOption_instanceGpuInfo)
		v.InstanceGpuInfo.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.MigrationEffort != "" {
		s.WriteString(schemas.AutoScalingGroupRecommendationOption_migrationEffort, string(v.MigrationEffort))
	}
	if v.PerformanceRisk != 0 {
		s.WriteFloat64(schemas.AutoScalingGroupRecommendationOption_performanceRisk, v.PerformanceRisk)
	}
	serializeProjectedUtilizationMetrics(s, schemas.AutoScalingGroupRecommendationOption_projectedUtilizationMetrics, v.ProjectedUtilizationMetrics)
	if v.Rank != 0 {
		s.WriteInt32(schemas.AutoScalingGroupRecommendationOption_rank, v.Rank)
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.AutoScalingGroupRecommendationOption_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityAfterDiscounts != nil {
		s.WriteStruct(schemas.AutoScalingGroupRecommendationOption_savingsOpportunityAfterDiscounts)
		v.SavingsOpportunityAfterDiscounts.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *AutoScalingGroupRecommendationOption) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AutoScalingGroupRecommendationOption, func(s *smithy.Schema) error {
		switch s {
		case schemas.AutoScalingGroupRecommendationOption_configuration:
			v.Configuration = &AutoScalingGroupConfiguration{}
			return v.Configuration.Deserialize(d)
		case schemas.AutoScalingGroupRecommendationOption_instanceGpuInfo:
			v.InstanceGpuInfo = &GpuInfo{}
			return v.InstanceGpuInfo.Deserialize(d)
		case schemas.AutoScalingGroupRecommendationOption_migrationEffort:
			var ev string
			if err := d.ReadString(schemas.AutoScalingGroupRecommendationOption_migrationEffort, &ev); err != nil {
				return err
			}
			v.MigrationEffort = MigrationEffort(ev)
			return nil
		case schemas.AutoScalingGroupRecommendationOption_performanceRisk:
			return d.ReadFloat64(schemas.AutoScalingGroupRecommendationOption_performanceRisk, &v.PerformanceRisk)
		case schemas.AutoScalingGroupRecommendationOption_projectedUtilizationMetrics:
			return deserializeProjectedUtilizationMetrics(d, schemas.AutoScalingGroupRecommendationOption_projectedUtilizationMetrics, &v.ProjectedUtilizationMetrics)
		case schemas.AutoScalingGroupRecommendationOption_rank:
			return d.ReadInt32(schemas.AutoScalingGroupRecommendationOption_rank, &v.Rank)
		case schemas.AutoScalingGroupRecommendationOption_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.AutoScalingGroupRecommendationOption_savingsOpportunityAfterDiscounts:
			v.SavingsOpportunityAfterDiscounts = &AutoScalingGroupSavingsOpportunityAfterDiscounts{}
			return v.SavingsOpportunityAfterDiscounts.Deserialize(d)
		}
		return nil
	})
}

//	Describes the savings opportunity for Auto Scaling group recommendations after
//
// applying the Savings Plans and Reserved Instances discounts.
//
// Savings opportunity represents the estimated monthly savings you can achieve by
// implementing Compute Optimizer recommendations.
type AutoScalingGroupSavingsOpportunityAfterDiscounts struct {

	//  An object that describes the estimated monthly savings possible by adopting
	// Compute Optimizer’s Auto Scaling group recommendations. This is based on the
	// Savings Plans and Reserved Instances pricing discounts.
	EstimatedMonthlySavings *AutoScalingGroupEstimatedMonthlySavings

	//  The estimated monthly savings possible as a percentage of monthly cost after
	// applying the Savings Plans and Reserved Instances discounts. This saving can be
	// achieved by adopting Compute Optimizer’s Auto Scaling group recommendations.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *AutoScalingGroupSavingsOpportunityAfterDiscounts) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.AutoScalingGroupSavingsOpportunityAfterDiscounts)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *AutoScalingGroupSavingsOpportunityAfterDiscounts) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.AutoScalingGroupSavingsOpportunityAfterDiscounts_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.AutoScalingGroupSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *AutoScalingGroupSavingsOpportunityAfterDiscounts) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AutoScalingGroupSavingsOpportunityAfterDiscounts, func(s *smithy.Schema) error {
		switch s {
		case schemas.AutoScalingGroupSavingsOpportunityAfterDiscounts_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &AutoScalingGroupEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.AutoScalingGroupSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.AutoScalingGroupSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

//	Describes the container configurations within the tasks of your Amazon ECS
//
// service.
type ContainerConfiguration struct {

	//  The name of the container.
	ContainerName *string

	//  The number of CPU units reserved for the container.
	Cpu *int32

	//  The memory size configurations for the container.
	MemorySizeConfiguration *MemorySizeConfiguration

	noSmithyDocumentSerde
}

func (v *ContainerConfiguration) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ContainerConfiguration)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ContainerConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerName != nil {
		s.WriteString(schemas.ContainerConfiguration_containerName, *v.ContainerName)
	}
	if v.Cpu != nil {
		s.WriteInt32(schemas.ContainerConfiguration_cpu, *v.Cpu)
	}
	if v.MemorySizeConfiguration != nil {
		s.WriteStruct(schemas.ContainerConfiguration_memorySizeConfiguration)
		v.MemorySizeConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *ContainerConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ContainerConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.ContainerConfiguration_containerName:
			v.ContainerName = new(string)
			return d.ReadString(schemas.ContainerConfiguration_containerName, v.ContainerName)
		case schemas.ContainerConfiguration_cpu:
			v.Cpu = new(int32)
			return d.ReadInt32(schemas.ContainerConfiguration_cpu, v.Cpu)
		case schemas.ContainerConfiguration_memorySizeConfiguration:
			v.MemorySizeConfiguration = &MemorySizeConfiguration{}
			return v.MemorySizeConfiguration.Deserialize(d)
		}
		return nil
	})
}

//	The CPU and memory recommendations for a container within the tasks of your
//
// Amazon ECS service.
type ContainerRecommendation struct {

	//  The name of the container.
	ContainerName *string

	//  The recommended number of CPU units reserved for the container.
	Cpu *int32

	//  The recommended memory size configurations for the container.
	MemorySizeConfiguration *MemorySizeConfiguration

	noSmithyDocumentSerde
}

func (v *ContainerRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ContainerRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ContainerRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerName != nil {
		s.WriteString(schemas.ContainerRecommendation_containerName, *v.ContainerName)
	}
	if v.Cpu != nil {
		s.WriteInt32(schemas.ContainerRecommendation_cpu, *v.Cpu)
	}
	if v.MemorySizeConfiguration != nil {
		s.WriteStruct(schemas.ContainerRecommendation_memorySizeConfiguration)
		v.MemorySizeConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *ContainerRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ContainerRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.ContainerRecommendation_containerName:
			v.ContainerName = new(string)
			return d.ReadString(schemas.ContainerRecommendation_containerName, v.ContainerName)
		case schemas.ContainerRecommendation_cpu:
			v.Cpu = new(int32)
			return d.ReadInt32(schemas.ContainerRecommendation_cpu, v.Cpu)
		case schemas.ContainerRecommendation_memorySizeConfiguration:
			v.MemorySizeConfiguration = &MemorySizeConfiguration{}
			return v.MemorySizeConfiguration.Deserialize(d)
		}
		return nil
	})
}

// Describes the performance risk ratings for a given resource type.
//
// Resources with a high or medium rating are at risk of not meeting the
// performance needs of their workloads, while resources with a low rating are
// performing well in their workloads.
type CurrentPerformanceRiskRatings struct {

	// A count of the applicable resource types with a high performance risk rating.
	High int64

	// A count of the applicable resource types with a low performance risk rating.
	Low int64

	// A count of the applicable resource types with a medium performance risk rating.
	Medium int64

	// A count of the applicable resource types with a very low performance risk
	// rating.
	VeryLow int64

	noSmithyDocumentSerde
}

func (v *CurrentPerformanceRiskRatings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.CurrentPerformanceRiskRatings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *CurrentPerformanceRiskRatings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.High != 0 {
		s.WriteInt64(schemas.CurrentPerformanceRiskRatings_high, v.High)
	}
	if v.Low != 0 {
		s.WriteInt64(schemas.CurrentPerformanceRiskRatings_low, v.Low)
	}
	if v.Medium != 0 {
		s.WriteInt64(schemas.CurrentPerformanceRiskRatings_medium, v.Medium)
	}
	if v.VeryLow != 0 {
		s.WriteInt64(schemas.CurrentPerformanceRiskRatings_veryLow, v.VeryLow)
	}
}
func (v *CurrentPerformanceRiskRatings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.CurrentPerformanceRiskRatings, func(s *smithy.Schema) error {
		switch s {
		case schemas.CurrentPerformanceRiskRatings_high:
			return d.ReadInt64(schemas.CurrentPerformanceRiskRatings_high, &v.High)
		case schemas.CurrentPerformanceRiskRatings_low:
			return d.ReadInt64(schemas.CurrentPerformanceRiskRatings_low, &v.Low)
		case schemas.CurrentPerformanceRiskRatings_medium:
			return d.ReadInt64(schemas.CurrentPerformanceRiskRatings_medium, &v.Medium)
		case schemas.CurrentPerformanceRiskRatings_veryLow:
			return d.ReadInt64(schemas.CurrentPerformanceRiskRatings_veryLow, &v.VeryLow)
		}
		return nil
	})
}

//	Defines the various metric parameters that can be customized, such as
//
// threshold and headroom.
type CustomizableMetricParameters struct {

	//  The headroom value in percentage used for the specified metric parameter.
	//
	// The following lists the valid values for CPU and memory utilization.
	//
	//   - CPU utilization: PERCENT_30 | PERCENT_20 | PERCENT_0
	//
	//   - Memory utilization: PERCENT_30 | PERCENT_20 | PERCENT_10
	Headroom CustomizableMetricHeadroom

	//  The threshold value used for the specified metric parameter.
	//
	// You can only specify the threshold value for CPU utilization.
	Threshold CustomizableMetricThreshold

	noSmithyDocumentSerde
}

func (v *CustomizableMetricParameters) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.CustomizableMetricParameters)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *CustomizableMetricParameters) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Headroom != "" {
		s.WriteString(schemas.CustomizableMetricParameters_headroom, string(v.Headroom))
	}
	if v.Threshold != "" {
		s.WriteString(schemas.CustomizableMetricParameters_threshold, string(v.Threshold))
	}
}
func (v *CustomizableMetricParameters) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.CustomizableMetricParameters, func(s *smithy.Schema) error {
		switch s {
		case schemas.CustomizableMetricParameters_headroom:
			var ev string
			if err := d.ReadString(schemas.CustomizableMetricParameters_headroom, &ev); err != nil {
				return err
			}
			v.Headroom = CustomizableMetricHeadroom(ev)
			return nil
		case schemas.CustomizableMetricParameters_threshold:
			var ev string
			if err := d.ReadString(schemas.CustomizableMetricParameters_threshold, &ev); err != nil {
				return err
			}
			v.Threshold = CustomizableMetricThreshold(ev)
			return nil
		}
		return nil
	})
}

// The configuration of the recommended RDS storage.
type DBStorageConfiguration struct {

	//  The size of the DB storage in gigabytes (GB).
	AllocatedStorage int32

	//  The provisioned IOPs of the DB storage.
	Iops *int32

	//  The maximum limit in gibibytes (GiB) to which Amazon RDS can automatically
	// scale the storage of the DB instance.
	MaxAllocatedStorage *int32

	//  The storage throughput of the DB storage.
	StorageThroughput *int32

	//  The type of DB storage.
	StorageType *string

	noSmithyDocumentSerde
}

func (v *DBStorageConfiguration) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.DBStorageConfiguration)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *DBStorageConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AllocatedStorage != 0 {
		s.WriteInt32(schemas.DBStorageConfiguration_allocatedStorage, v.AllocatedStorage)
	}
	if v.Iops != nil {
		s.WriteInt32(schemas.DBStorageConfiguration_iops, *v.Iops)
	}
	if v.MaxAllocatedStorage != nil {
		s.WriteInt32(schemas.DBStorageConfiguration_maxAllocatedStorage, *v.MaxAllocatedStorage)
	}
	if v.StorageThroughput != nil {
		s.WriteInt32(schemas.DBStorageConfiguration_storageThroughput, *v.StorageThroughput)
	}
	if v.StorageType != nil {
		s.WriteString(schemas.DBStorageConfiguration_storageType, *v.StorageType)
	}
}
func (v *DBStorageConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.DBStorageConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.DBStorageConfiguration_allocatedStorage:
			return d.ReadInt32(schemas.DBStorageConfiguration_allocatedStorage, &v.AllocatedStorage)
		case schemas.DBStorageConfiguration_iops:
			v.Iops = new(int32)
			return d.ReadInt32(schemas.DBStorageConfiguration_iops, v.Iops)
		case schemas.DBStorageConfiguration_maxAllocatedStorage:
			v.MaxAllocatedStorage = new(int32)
			return d.ReadInt32(schemas.DBStorageConfiguration_maxAllocatedStorage, v.MaxAllocatedStorage)
		case schemas.DBStorageConfiguration_storageThroughput:
			v.StorageThroughput = new(int32)
			return d.ReadInt32(schemas.DBStorageConfiguration_storageThroughput, v.StorageThroughput)
		case schemas.DBStorageConfiguration_storageType:
			v.StorageType = new(string)
			return d.ReadString(schemas.DBStorageConfiguration_storageType, v.StorageType)
		}
		return nil
	})
}

// Describes the effective recommendation preferences for Amazon EBS volumes.
type EBSEffectiveRecommendationPreferences struct {

	// The number of days for which utilization metrics were analyzed for the volume.
	LookBackPeriod LookBackPeriodPreference

	//  Describes the savings estimation mode preference applied for calculating
	// savings opportunity for Amazon EBS volumes.
	SavingsEstimationMode *EBSSavingsEstimationMode

	noSmithyDocumentSerde
}

func (v *EBSEffectiveRecommendationPreferences) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EBSEffectiveRecommendationPreferences)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EBSEffectiveRecommendationPreferences) SerializeMembers(s smithy.ShapeSerializer) {
	if v.LookBackPeriod != "" {
		s.WriteString(schemas.EBSEffectiveRecommendationPreferences_lookBackPeriod, string(v.LookBackPeriod))
	}
	if v.SavingsEstimationMode != nil {
		s.WriteStruct(schemas.EBSEffectiveRecommendationPreferences_savingsEstimationMode)
		v.SavingsEstimationMode.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *EBSEffectiveRecommendationPreferences) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EBSEffectiveRecommendationPreferences, func(s *smithy.Schema) error {
		switch s {
		case schemas.EBSEffectiveRecommendationPreferences_lookBackPeriod:
			var ev string
			if err := d.ReadString(schemas.EBSEffectiveRecommendationPreferences_lookBackPeriod, &ev); err != nil {
				return err
			}
			v.LookBackPeriod = LookBackPeriodPreference(ev)
			return nil
		case schemas.EBSEffectiveRecommendationPreferences_savingsEstimationMode:
			v.SavingsEstimationMode = &EBSSavingsEstimationMode{}
			return v.SavingsEstimationMode.Deserialize(d)
		}
		return nil
	})
}

//	An object that describes the estimated monthly savings possible by adopting
//
// Compute Optimizer’s Amazon EBS volume recommendations. This includes any
// applicable discounts.
type EBSEstimatedMonthlySavings struct {

	//  The currency of the estimated monthly savings.
	Currency Currency

	//  The value of the estimated monthly savings.
	Value float64

	noSmithyDocumentSerde
}

func (v *EBSEstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EBSEstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EBSEstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.EBSEstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.EBSEstimatedMonthlySavings_value, v.Value)
	}
}
func (v *EBSEstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EBSEstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.EBSEstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.EBSEstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.EBSEstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.EBSEstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

// Describes a filter that returns a more specific list of Amazon Elastic Block
// Store (Amazon EBS) volume recommendations. Use this filter with the GetEBSVolumeRecommendationsaction.
//
// You can use LambdaFunctionRecommendationFilter with the GetLambdaFunctionRecommendations action, JobFilter with
// the DescribeRecommendationExportJobsaction, and Filter with the GetAutoScalingGroupRecommendations and GetEC2InstanceRecommendations actions.
type EBSFilter struct {

	// The name of the filter.
	//
	// Specify Finding to return recommendations with a specific finding
	// classification (for example, NotOptimized ).
	//
	// You can filter your Amazon EBS volume recommendations by tag:key and tag-key
	// tags.
	//
	// A tag:key is a key and value combination of a tag assigned to your Amazon EBS
	// volume recommendations. Use the tag key in the filter name and the tag value as
	// the filter value. For example, to find all Amazon EBS volume recommendations
	// that have a tag with the key of Owner and the value of TeamA , specify tag:Owner
	// for the filter name and TeamA for the filter value.
	//
	// A tag-key is the key of a tag assigned to your Amazon EBS volume
	// recommendations. Use this filter to find all of your Amazon EBS volume
	// recommendations that have a tag with a specific key. This doesn’t consider the
	// tag value. For example, you can find your Amazon EBS volume recommendations with
	// a tag key value of Owner or without any tag keys assigned.
	Name EBSFilterName

	// The value of the filter.
	//
	// The valid values are Optimized , or NotOptimized .
	Values []string

	noSmithyDocumentSerde
}

func (v *EBSFilter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EBSFilter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EBSFilter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.EBSFilter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.EBSFilter_values, v.Values)
}
func (v *EBSFilter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EBSFilter, func(s *smithy.Schema) error {
		switch s {
		case schemas.EBSFilter_name:
			var ev string
			if err := d.ReadString(schemas.EBSFilter_name, &ev); err != nil {
				return err
			}
			v.Name = EBSFilterName(ev)
			return nil
		case schemas.EBSFilter_values:
			return deserializeFilterValues(d, schemas.EBSFilter_values, &v.Values)
		}
		return nil
	})
}

//	Describes the savings estimation mode used for calculating savings opportunity
//
// for Amazon EBS volumes.
type EBSSavingsEstimationMode struct {

	//  Describes the source for calculating the savings opportunity for Amazon EBS
	// volumes.
	Source EBSSavingsEstimationModeSource

	noSmithyDocumentSerde
}

func (v *EBSSavingsEstimationMode) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EBSSavingsEstimationMode)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EBSSavingsEstimationMode) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Source != "" {
		s.WriteString(schemas.EBSSavingsEstimationMode_source, string(v.Source))
	}
}
func (v *EBSSavingsEstimationMode) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EBSSavingsEstimationMode, func(s *smithy.Schema) error {
		switch s {
		case schemas.EBSSavingsEstimationMode_source:
			var ev string
			if err := d.ReadString(schemas.EBSSavingsEstimationMode_source, &ev); err != nil {
				return err
			}
			v.Source = EBSSavingsEstimationModeSource(ev)
			return nil
		}
		return nil
	})
}

//	Describes the savings opportunity for Amazon EBS volume recommendations after
//
// applying specific discounts.
type EBSSavingsOpportunityAfterDiscounts struct {

	//  The estimated monthly savings possible as a percentage of monthly cost by
	// adopting Compute Optimizer’s Amazon EBS volume recommendations. This saving
	// includes any applicable discounts.
	EstimatedMonthlySavings *EBSEstimatedMonthlySavings

	//  The estimated monthly savings possible as a percentage of monthly cost after
	// applying the specific discounts. This saving can be achieved by adopting Compute
	// Optimizer’s Amazon EBS volume recommendations.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *EBSSavingsOpportunityAfterDiscounts) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EBSSavingsOpportunityAfterDiscounts)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EBSSavingsOpportunityAfterDiscounts) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.EBSSavingsOpportunityAfterDiscounts_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.EBSSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *EBSSavingsOpportunityAfterDiscounts) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EBSSavingsOpportunityAfterDiscounts, func(s *smithy.Schema) error {
		switch s {
		case schemas.EBSSavingsOpportunityAfterDiscounts_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &EBSEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.EBSSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.EBSSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

// Describes a utilization metric of an Amazon Elastic Block Store (Amazon EBS)
// volume.
//
// Compare the utilization metric data of your resource against its projected
// utilization metric data to determine the performance difference between your
// current resource and the recommended option.
type EBSUtilizationMetric struct {

	// The name of the utilization metric.
	//
	// The following utilization metrics are available:
	//
	//   - VolumeReadOpsPerSecond - The completed read operations per second from the
	//   volume in a specified period of time.
	//
	// Unit: Count
	//
	//   - VolumeWriteOpsPerSecond - The completed write operations per second to the
	//   volume in a specified period of time.
	//
	// Unit: Count
	//
	//   - VolumeReadBytesPerSecond - The bytes read per second from the volume in a
	//   specified period of time.
	//
	// Unit: Bytes
	//
	//   - VolumeWriteBytesPerSecond - The bytes written to the volume in a specified
	//   period of time.
	//
	// Unit: Bytes
	//
	//   - VolumeIOPSExceeded - Indicates whether the volume's provisioned IOPS
	//   performance was exceeded in a specified period of time. A value of 1 means the
	//   provisioned IOPS were exceeded; a value of 0 means they were not.
	//
	// Unit: None
	//
	//   - VolumeThroughputExceeded - Indicates whether the volume's provisioned
	//   throughput performance was exceeded in a specified period of time. A value of
	//   1 means the provisioned throughput was exceeded; a value of 0 means it was not.
	//
	// Unit: None
	Name EBSMetricName

	// The statistic of the utilization metric.
	//
	// The Compute Optimizer API, Command Line Interface (CLI), and SDKs return
	// utilization metrics using only the Maximum statistic, which is the highest
	// value observed during the specified period.
	//
	// The Compute Optimizer console displays graphs for some utilization metrics
	// using the Average statistic, which is the value of Sum / SampleCount during the
	// specified period. For more information, see [Viewing resource recommendations]in the Compute Optimizer User
	// Guide. You can also get averaged utilization metric data for your resources
	// using Amazon CloudWatch. For more information, see the [Amazon CloudWatch User Guide].
	//
	// [Viewing resource recommendations]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/viewing-recommendations.html
	// [Amazon CloudWatch User Guide]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html
	Statistic MetricStatistic

	// The value of the utilization metric.
	Value float64

	noSmithyDocumentSerde
}

func (v *EBSUtilizationMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EBSUtilizationMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EBSUtilizationMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.EBSUtilizationMetric_name, string(v.Name))
	}
	if v.Statistic != "" {
		s.WriteString(schemas.EBSUtilizationMetric_statistic, string(v.Statistic))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.EBSUtilizationMetric_value, v.Value)
	}
}
func (v *EBSUtilizationMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EBSUtilizationMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.EBSUtilizationMetric_name:
			var ev string
			if err := d.ReadString(schemas.EBSUtilizationMetric_name, &ev); err != nil {
				return err
			}
			v.Name = EBSMetricName(ev)
			return nil
		case schemas.EBSUtilizationMetric_statistic:
			var ev string
			if err := d.ReadString(schemas.EBSUtilizationMetric_statistic, &ev); err != nil {
				return err
			}
			v.Statistic = MetricStatistic(ev)
			return nil
		case schemas.EBSUtilizationMetric_value:
			return d.ReadFloat64(schemas.EBSUtilizationMetric_value, &v.Value)
		}
		return nil
	})
}

// Describes the effective recommendation preferences for Amazon ECS services.
type ECSEffectiveRecommendationPreferences struct {

	//  The number of days the Amazon ECS service utilization metrics were analyzed.
	LookBackPeriod LookBackPeriodPreference

	//  Describes the savings estimation mode preference applied for calculating
	// savings opportunity for Amazon ECS services.
	SavingsEstimationMode *ECSSavingsEstimationMode

	noSmithyDocumentSerde
}

func (v *ECSEffectiveRecommendationPreferences) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSEffectiveRecommendationPreferences)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSEffectiveRecommendationPreferences) SerializeMembers(s smithy.ShapeSerializer) {
	if v.LookBackPeriod != "" {
		s.WriteString(schemas.ECSEffectiveRecommendationPreferences_lookBackPeriod, string(v.LookBackPeriod))
	}
	if v.SavingsEstimationMode != nil {
		s.WriteStruct(schemas.ECSEffectiveRecommendationPreferences_savingsEstimationMode)
		v.SavingsEstimationMode.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *ECSEffectiveRecommendationPreferences) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSEffectiveRecommendationPreferences, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSEffectiveRecommendationPreferences_lookBackPeriod:
			var ev string
			if err := d.ReadString(schemas.ECSEffectiveRecommendationPreferences_lookBackPeriod, &ev); err != nil {
				return err
			}
			v.LookBackPeriod = LookBackPeriodPreference(ev)
			return nil
		case schemas.ECSEffectiveRecommendationPreferences_savingsEstimationMode:
			v.SavingsEstimationMode = &ECSSavingsEstimationMode{}
			return v.SavingsEstimationMode.Deserialize(d)
		}
		return nil
	})
}

//	Describes the estimated monthly savings possible for Amazon ECS services by
//
// adopting Compute Optimizer recommendations. This is based on Amazon ECS service
// pricing after applying Savings Plans discounts.
type ECSEstimatedMonthlySavings struct {

	//  The currency of the estimated monthly savings.
	Currency Currency

	//  The value of the estimated monthly savings for Amazon ECS services.
	Value float64

	noSmithyDocumentSerde
}

func (v *ECSEstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSEstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSEstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.ECSEstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.ECSEstimatedMonthlySavings_value, v.Value)
	}
}
func (v *ECSEstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSEstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSEstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.ECSEstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.ECSEstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.ECSEstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

//	Describes the savings estimation mode used for calculating savings opportunity
//
// for Amazon ECS services.
type ECSSavingsEstimationMode struct {

	//  Describes the source for calculating the savings opportunity for Amazon ECS
	// services.
	Source ECSSavingsEstimationModeSource

	noSmithyDocumentSerde
}

func (v *ECSSavingsEstimationMode) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSSavingsEstimationMode)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSSavingsEstimationMode) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Source != "" {
		s.WriteString(schemas.ECSSavingsEstimationMode_source, string(v.Source))
	}
}
func (v *ECSSavingsEstimationMode) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSSavingsEstimationMode, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSSavingsEstimationMode_source:
			var ev string
			if err := d.ReadString(schemas.ECSSavingsEstimationMode_source, &ev); err != nil {
				return err
			}
			v.Source = ECSSavingsEstimationModeSource(ev)
			return nil
		}
		return nil
	})
}

//	Describes the savings opportunity for Amazon ECS service recommendations after
//
// applying Savings Plans discounts.
//
// Savings opportunity represents the estimated monthly savings after applying
// Savings Plans discounts. You can achieve this by implementing a given Compute
// Optimizer recommendation.
type ECSSavingsOpportunityAfterDiscounts struct {

	//  The estimated monthly savings possible by adopting Compute Optimizer’s Amazon
	// ECS service recommendations. This includes any applicable Savings Plans
	// discounts.
	EstimatedMonthlySavings *ECSEstimatedMonthlySavings

	//  The estimated monthly savings possible as a percentage of monthly cost by
	// adopting Compute Optimizer’s Amazon ECS service recommendations. This includes
	// any applicable Savings Plans discounts.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *ECSSavingsOpportunityAfterDiscounts) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSSavingsOpportunityAfterDiscounts)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSSavingsOpportunityAfterDiscounts) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.ECSSavingsOpportunityAfterDiscounts_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.ECSSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *ECSSavingsOpportunityAfterDiscounts) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSSavingsOpportunityAfterDiscounts, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSSavingsOpportunityAfterDiscounts_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &ECSEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.ECSSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.ECSSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

//	Describes the projected metrics of an Amazon ECS service recommendation
//
// option.
//
// To determine the performance difference between your current Amazon ECS service
// and the recommended option, compare the metric data of your service against its
// projected metric data.
type ECSServiceProjectedMetric struct {

	//  The lower bound values for the projected metric.
	LowerBoundValues []float64

	//  The name of the projected metric.
	//
	// The following metrics are available:
	//
	//   - Cpu — The percentage of allocated compute units that are currently in use on
	//   the service tasks.
	//
	//   - Memory — The percentage of memory that's currently in use on the service
	//   tasks.
	Name ECSServiceMetricName

	//  The timestamps of the projected metric.
	Timestamps []time.Time

	//  The upper bound values for the projected metric.
	UpperBoundValues []float64

	noSmithyDocumentSerde
}

func (v *ECSServiceProjectedMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSServiceProjectedMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSServiceProjectedMetric) SerializeMembers(s smithy.ShapeSerializer) {
	serializeMetricValues(s, schemas.ECSServiceProjectedMetric_lowerBoundValues, v.LowerBoundValues)
	if v.Name != "" {
		s.WriteString(schemas.ECSServiceProjectedMetric_name, string(v.Name))
	}
	serializeTimestamps(s, schemas.ECSServiceProjectedMetric_timestamps, v.Timestamps)
	serializeMetricValues(s, schemas.ECSServiceProjectedMetric_upperBoundValues, v.UpperBoundValues)
}
func (v *ECSServiceProjectedMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSServiceProjectedMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSServiceProjectedMetric_lowerBoundValues:
			return deserializeMetricValues(d, schemas.ECSServiceProjectedMetric_lowerBoundValues, &v.LowerBoundValues)
		case schemas.ECSServiceProjectedMetric_name:
			var ev string
			if err := d.ReadString(schemas.ECSServiceProjectedMetric_name, &ev); err != nil {
				return err
			}
			v.Name = ECSServiceMetricName(ev)
			return nil
		case schemas.ECSServiceProjectedMetric_timestamps:
			return deserializeTimestamps(d, schemas.ECSServiceProjectedMetric_timestamps, &v.Timestamps)
		case schemas.ECSServiceProjectedMetric_upperBoundValues:
			return deserializeMetricValues(d, schemas.ECSServiceProjectedMetric_upperBoundValues, &v.UpperBoundValues)
		}
		return nil
	})
}

//	Describes the projected utilization metrics of an Amazon ECS service
//
// recommendation option.
//
// To determine the performance difference between your current Amazon ECS service
// and the recommended option, compare the utilization metric data of your service
// against its projected utilization metric data.
type ECSServiceProjectedUtilizationMetric struct {

	//  The lower bound values for the projected utilization metrics.
	LowerBoundValue float64

	//  The name of the projected utilization metric.
	//
	// The following utilization metrics are available:
	//
	//   - Cpu — The percentage of allocated compute units that are currently in use on
	//   the service tasks.
	//
	//   - Memory — The percentage of memory that's currently in use on the service
	//   tasks.
	Name ECSServiceMetricName

	// The statistic of the projected utilization metric.
	//
	// The Compute Optimizer API, Command Line Interface (CLI), and SDKs return
	// utilization metrics using only the Maximum statistic, which is the highest
	// value observed during the specified period.
	//
	// The Compute Optimizer console displays graphs for some utilization metrics
	// using the Average statistic, which is the value of Sum / SampleCount during the
	// specified period. For more information, see [Viewing resource recommendations]in the Compute Optimizer User
	// Guide. You can also get averaged utilization metric data for your resources
	// using Amazon CloudWatch. For more information, see the [Amazon CloudWatch User Guide].
	//
	// [Viewing resource recommendations]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/viewing-recommendations.html
	// [Amazon CloudWatch User Guide]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html
	Statistic ECSServiceMetricStatistic

	//  The upper bound values for the projected utilization metrics.
	UpperBoundValue float64

	noSmithyDocumentSerde
}

func (v *ECSServiceProjectedUtilizationMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSServiceProjectedUtilizationMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSServiceProjectedUtilizationMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.LowerBoundValue != 0 {
		s.WriteFloat64(schemas.ECSServiceProjectedUtilizationMetric_lowerBoundValue, v.LowerBoundValue)
	}
	if v.Name != "" {
		s.WriteString(schemas.ECSServiceProjectedUtilizationMetric_name, string(v.Name))
	}
	if v.Statistic != "" {
		s.WriteString(schemas.ECSServiceProjectedUtilizationMetric_statistic, string(v.Statistic))
	}
	if v.UpperBoundValue != 0 {
		s.WriteFloat64(schemas.ECSServiceProjectedUtilizationMetric_upperBoundValue, v.UpperBoundValue)
	}
}
func (v *ECSServiceProjectedUtilizationMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSServiceProjectedUtilizationMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSServiceProjectedUtilizationMetric_lowerBoundValue:
			return d.ReadFloat64(schemas.ECSServiceProjectedUtilizationMetric_lowerBoundValue, &v.LowerBoundValue)
		case schemas.ECSServiceProjectedUtilizationMetric_name:
			var ev string
			if err := d.ReadString(schemas.ECSServiceProjectedUtilizationMetric_name, &ev); err != nil {
				return err
			}
			v.Name = ECSServiceMetricName(ev)
			return nil
		case schemas.ECSServiceProjectedUtilizationMetric_statistic:
			var ev string
			if err := d.ReadString(schemas.ECSServiceProjectedUtilizationMetric_statistic, &ev); err != nil {
				return err
			}
			v.Statistic = ECSServiceMetricStatistic(ev)
			return nil
		case schemas.ECSServiceProjectedUtilizationMetric_upperBoundValue:
			return d.ReadFloat64(schemas.ECSServiceProjectedUtilizationMetric_upperBoundValue, &v.UpperBoundValue)
		}
		return nil
	})
}

// Describes an Amazon ECS service recommendation.
type ECSServiceRecommendation struct {

	//  The Amazon Web Services account ID of the Amazon ECS service.
	AccountId *string

	//  The risk of the current Amazon ECS service not meeting the performance needs
	// of its workloads. The higher the risk, the more likely the current service can't
	// meet the performance requirements of its workload.
	CurrentPerformanceRisk CurrentPerformanceRisk

	//  The configuration of the current Amazon ECS service.
	CurrentServiceConfiguration *ServiceConfiguration

	//  Describes the effective recommendation preferences for Amazon ECS services.
	EffectiveRecommendationPreferences *ECSEffectiveRecommendationPreferences

	//  The finding classification of an Amazon ECS service.
	//
	// Findings for Amazon ECS services include:
	//
	//   - Underprovisioned — When Compute Optimizer detects that there’s not enough
	//   memory or CPU, an Amazon ECS service is considered under-provisioned. An
	//   under-provisioned service might result in poor application performance.
	//
	//   - Overprovisioned — When Compute Optimizer detects that there’s excessive
	//   memory or CPU, an Amazon ECS service is considered over-provisioned. An
	//   over-provisioned service might result in additional infrastructure costs.
	//
	//   - Optimized — When both the CPU and memory of your Amazon ECS service meet the
	//   performance requirements of your workload, the service is considered optimized.
	Finding ECSServiceRecommendationFinding

	//  The reason for the finding classification of an Amazon ECS service.
	//
	// Finding reason codes for Amazon ECS services include:
	//
	//   - CPUUnderprovisioned — The service CPU configuration can be sized up to
	//   enhance the performance of your workload. This is identified by analyzing the
	//   CPUUtilization metric of the current service during the look-back period.
	//
	//   - CPUOverprovisioned — The service CPU configuration can be sized down while
	//   still meeting the performance requirements of your workload. This is identified
	//   by analyzing the CPUUtilization metric of the current service during the
	//   look-back period.
	//
	//   - MemoryUnderprovisioned — The service memory configuration can be sized up to
	//   enhance the performance of your workload. This is identified by analyzing the
	//   MemoryUtilization metric of the current service during the look-back period.
	//
	//   - MemoryOverprovisioned — The service memory configuration can be sized down
	//   while still meeting the performance requirements of your workload. This is
	//   identified by analyzing the MemoryUtilization metric of the current service
	//   during the look-back period.
	FindingReasonCodes []ECSServiceRecommendationFindingReasonCode

	//  The timestamp of when the Amazon ECS service recommendation was last
	// generated.
	LastRefreshTimestamp *time.Time

	//  The launch type the Amazon ECS service is using.
	//
	// Compute Optimizer only supports the Fargate launch type.
	LaunchType ECSServiceLaunchType

	//  The number of days the Amazon ECS service utilization metrics were analyzed.
	LookbackPeriodInDays float64

	//  The Amazon Resource Name (ARN) of the current Amazon ECS service.
	//
	// The following is the format of the ARN:
	//
	//     arn:aws:ecs:region:aws_account_id:service/cluster-name/service-name
	ServiceArn *string

	//  An array of objects that describe the recommendation options for the Amazon
	// ECS service.
	ServiceRecommendationOptions []ECSServiceRecommendationOption

	//  A list of tags assigned to your Amazon ECS service recommendations.
	Tags []Tag

	//  An array of objects that describe the utilization metrics of the Amazon ECS
	// service.
	UtilizationMetrics []ECSServiceUtilizationMetric

	noSmithyDocumentSerde
}

func (v *ECSServiceRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSServiceRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSServiceRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.ECSServiceRecommendation_accountId, *v.AccountId)
	}
	if v.CurrentPerformanceRisk != "" {
		s.WriteString(schemas.ECSServiceRecommendation_currentPerformanceRisk, string(v.CurrentPerformanceRisk))
	}
	if v.CurrentServiceConfiguration != nil {
		s.WriteStruct(schemas.ECSServiceRecommendation_currentServiceConfiguration)
		v.CurrentServiceConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EffectiveRecommendationPreferences != nil {
		s.WriteStruct(schemas.ECSServiceRecommendation_effectiveRecommendationPreferences)
		v.EffectiveRecommendationPreferences.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Finding != "" {
		s.WriteString(schemas.ECSServiceRecommendation_finding, string(v.Finding))
	}
	serializeECSServiceRecommendationFindingReasonCodes(s, schemas.ECSServiceRecommendation_findingReasonCodes, v.FindingReasonCodes)
	if v.LastRefreshTimestamp != nil {
		s.WriteTime(schemas.ECSServiceRecommendation_lastRefreshTimestamp, *v.LastRefreshTimestamp)
	}
	if v.LaunchType != "" {
		s.WriteString(schemas.ECSServiceRecommendation_launchType, string(v.LaunchType))
	}
	if v.LookbackPeriodInDays != 0 {
		s.WriteFloat64(schemas.ECSServiceRecommendation_lookbackPeriodInDays, v.LookbackPeriodInDays)
	}
	if v.ServiceArn != nil {
		s.WriteString(schemas.ECSServiceRecommendation_serviceArn, *v.ServiceArn)
	}
	serializeECSServiceRecommendationOptions(s, schemas.ECSServiceRecommendation_serviceRecommendationOptions, v.ServiceRecommendationOptions)
	serializeTags(s, schemas.ECSServiceRecommendation_tags, v.Tags)
	serializeECSServiceUtilizationMetrics(s, schemas.ECSServiceRecommendation_utilizationMetrics, v.UtilizationMetrics)
}
func (v *ECSServiceRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSServiceRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSServiceRecommendation_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.ECSServiceRecommendation_accountId, v.AccountId)
		case schemas.ECSServiceRecommendation_currentPerformanceRisk:
			var ev string
			if err := d.ReadString(schemas.ECSServiceRecommendation_currentPerformanceRisk, &ev); err != nil {
				return err
			}
			v.CurrentPerformanceRisk = CurrentPerformanceRisk(ev)
			return nil
		case schemas.ECSServiceRecommendation_currentServiceConfiguration:
			v.CurrentServiceConfiguration = &ServiceConfiguration{}
			return v.CurrentServiceConfiguration.Deserialize(d)
		case schemas.ECSServiceRecommendation_effectiveRecommendationPreferences:
			v.EffectiveRecommendationPreferences = &ECSEffectiveRecommendationPreferences{}
			return v.EffectiveRecommendationPreferences.Deserialize(d)
		case schemas.ECSServiceRecommendation_finding:
			var ev string
			if err := d.ReadString(schemas.ECSServiceRecommendation_finding, &ev); err != nil {
				return err
			}
			v.Finding = ECSServiceRecommendationFinding(ev)
			return nil
		case schemas.ECSServiceRecommendation_findingReasonCodes:
			return deserializeECSServiceRecommendationFindingReasonCodes(d, schemas.ECSServiceRecommendation_findingReasonCodes, &v.FindingReasonCodes)
		case schemas.ECSServiceRecommendation_lastRefreshTimestamp:
			v.LastRefreshTimestamp = new(time.Time)
			return d.ReadTime(schemas.ECSServiceRecommendation_lastRefreshTimestamp, v.LastRefreshTimestamp)
		case schemas.ECSServiceRecommendation_launchType:
			var ev string
			if err := d.ReadString(schemas.ECSServiceRecommendation_launchType, &ev); err != nil {
				return err
			}
			v.LaunchType = ECSServiceLaunchType(ev)
			return nil
		case schemas.ECSServiceRecommendation_lookbackPeriodInDays:
			return d.ReadFloat64(schemas.ECSServiceRecommendation_lookbackPeriodInDays, &v.LookbackPeriodInDays)
		case schemas.ECSServiceRecommendation_serviceArn:
			v.ServiceArn = new(string)
			return d.ReadString(schemas.ECSServiceRecommendation_serviceArn, v.ServiceArn)
		case schemas.ECSServiceRecommendation_serviceRecommendationOptions:
			return deserializeECSServiceRecommendationOptions(d, schemas.ECSServiceRecommendation_serviceRecommendationOptions, &v.ServiceRecommendationOptions)
		case schemas.ECSServiceRecommendation_tags:
			return deserializeTags(d, schemas.ECSServiceRecommendation_tags, &v.Tags)
		case schemas.ECSServiceRecommendation_utilizationMetrics:
			return deserializeECSServiceUtilizationMetrics(d, schemas.ECSServiceRecommendation_utilizationMetrics, &v.UtilizationMetrics)
		}
		return nil
	})
}

//	Describes a filter that returns a more specific list of Amazon ECS service
//
// recommendations. Use this filter with the GetECSServiceRecommendationsaction.
type ECSServiceRecommendationFilter struct {

	//  The name of the filter.
	//
	// Specify Finding to return recommendations with a specific finding
	// classification.
	//
	// Specify FindingReasonCode to return recommendations with a specific finding
	// reason code.
	//
	// You can filter your Amazon ECS service recommendations by tag:key and tag-key
	// tags.
	//
	// A tag:key is a key and value combination of a tag assigned to your Amazon ECS
	// service recommendations. Use the tag key in the filter name and the tag value as
	// the filter value. For example, to find all Amazon ECS service recommendations
	// that have a tag with the key of Owner and the value of TeamA , specify tag:Owner
	// for the filter name and TeamA for the filter value.
	//
	// A tag-key is the key of a tag assigned to your Amazon ECS service
	// recommendations. Use this filter to find all of your Amazon ECS service
	// recommendations that have a tag with a specific key. This doesn’t consider the
	// tag value. For example, you can find your Amazon ECS service recommendations
	// with a tag key value of Owner or without any tag keys assigned.
	Name ECSServiceRecommendationFilterName

	//  The value of the filter.
	//
	// The valid values for this parameter are as follows:
	//
	//   - If you specify the name parameter as Finding , specify Optimized ,
	//   Underprovisioned , or Overprovisioned .
	//
	//   - If you specify the name parameter as FindingReasonCode , specify
	//   CPUUnderprovisioned , CPUOverprovisioned , MemoryUnderprovisioned , or
	//   MemoryOverprovisioned .
	Values []string

	noSmithyDocumentSerde
}

func (v *ECSServiceRecommendationFilter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSServiceRecommendationFilter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSServiceRecommendationFilter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.ECSServiceRecommendationFilter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.ECSServiceRecommendationFilter_values, v.Values)
}
func (v *ECSServiceRecommendationFilter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSServiceRecommendationFilter, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSServiceRecommendationFilter_name:
			var ev string
			if err := d.ReadString(schemas.ECSServiceRecommendationFilter_name, &ev); err != nil {
				return err
			}
			v.Name = ECSServiceRecommendationFilterName(ev)
			return nil
		case schemas.ECSServiceRecommendationFilter_values:
			return deserializeFilterValues(d, schemas.ECSServiceRecommendationFilter_values, &v.Values)
		}
		return nil
	})
}

// Describes the recommendation options for an Amazon ECS service.
type ECSServiceRecommendationOption struct {

	//  The CPU and memory size recommendations for the containers within the task of
	// your Amazon ECS service.
	ContainerRecommendations []ContainerRecommendation

	//  The CPU size of the Amazon ECS service recommendation option.
	Cpu *int32

	//  The memory size of the Amazon ECS service recommendation option.
	Memory *int32

	//  An array of objects that describe the projected utilization metrics of the
	// Amazon ECS service recommendation option.
	ProjectedUtilizationMetrics []ECSServiceProjectedUtilizationMetric

	// Describes the savings opportunity for recommendations of a given resource type
	// or for the recommendation option of an individual resource.
	//
	// Savings opportunity represents the estimated monthly savings you can achieve by
	// implementing a given Compute Optimizer recommendation.
	//
	// Savings opportunity data requires that you opt in to Cost Explorer, as well as
	// activate Receive Amazon EC2 resource recommendations in the Cost Explorer
	// preferences page. That creates a connection between Cost Explorer and Compute
	// Optimizer. With this connection, Cost Explorer generates savings estimates
	// considering the price of existing resources, the price of recommended resources,
	// and historical usage data. Estimated monthly savings reflects the projected
	// dollar savings associated with each of the recommendations generated. For more
	// information, see [Enabling Cost Explorer]and [Optimizing your cost with Rightsizing Recommendations] in the Cost Management User Guide.
	//
	// [Optimizing your cost with Rightsizing Recommendations]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-rightsizing.html
	// [Enabling Cost Explorer]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-enable.html
	SavingsOpportunity *SavingsOpportunity

	//  Describes the savings opportunity for Amazon ECS service recommendations or
	// for the recommendation option.
	//
	// Savings opportunity represents the estimated monthly savings after applying
	// Savings Plans discounts. You can achieve this by implementing a given Compute
	// Optimizer recommendation.
	SavingsOpportunityAfterDiscounts *ECSSavingsOpportunityAfterDiscounts

	noSmithyDocumentSerde
}

func (v *ECSServiceRecommendationOption) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSServiceRecommendationOption)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSServiceRecommendationOption) SerializeMembers(s smithy.ShapeSerializer) {
	serializeContainerRecommendations(s, schemas.ECSServiceRecommendationOption_containerRecommendations, v.ContainerRecommendations)
	if v.Cpu != nil {
		s.WriteInt32(schemas.ECSServiceRecommendationOption_cpu, *v.Cpu)
	}
	if v.Memory != nil {
		s.WriteInt32(schemas.ECSServiceRecommendationOption_memory, *v.Memory)
	}
	serializeECSServiceProjectedUtilizationMetrics(s, schemas.ECSServiceRecommendationOption_projectedUtilizationMetrics, v.ProjectedUtilizationMetrics)
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.ECSServiceRecommendationOption_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityAfterDiscounts != nil {
		s.WriteStruct(schemas.ECSServiceRecommendationOption_savingsOpportunityAfterDiscounts)
		v.SavingsOpportunityAfterDiscounts.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *ECSServiceRecommendationOption) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSServiceRecommendationOption, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSServiceRecommendationOption_containerRecommendations:
			return deserializeContainerRecommendations(d, schemas.ECSServiceRecommendationOption_containerRecommendations, &v.ContainerRecommendations)
		case schemas.ECSServiceRecommendationOption_cpu:
			v.Cpu = new(int32)
			return d.ReadInt32(schemas.ECSServiceRecommendationOption_cpu, v.Cpu)
		case schemas.ECSServiceRecommendationOption_memory:
			v.Memory = new(int32)
			return d.ReadInt32(schemas.ECSServiceRecommendationOption_memory, v.Memory)
		case schemas.ECSServiceRecommendationOption_projectedUtilizationMetrics:
			return deserializeECSServiceProjectedUtilizationMetrics(d, schemas.ECSServiceRecommendationOption_projectedUtilizationMetrics, &v.ProjectedUtilizationMetrics)
		case schemas.ECSServiceRecommendationOption_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.ECSServiceRecommendationOption_savingsOpportunityAfterDiscounts:
			v.SavingsOpportunityAfterDiscounts = &ECSSavingsOpportunityAfterDiscounts{}
			return v.SavingsOpportunityAfterDiscounts.Deserialize(d)
		}
		return nil
	})
}

//	Describes the projected metrics of an Amazon ECS service recommendation
//
// option.
//
// To determine the performance difference between your current Amazon ECS service
// and the recommended option, compare the metric data of your service against its
// projected metric data.
type ECSServiceRecommendedOptionProjectedMetric struct {

	//  An array of objects that describe the projected metric.
	ProjectedMetrics []ECSServiceProjectedMetric

	//  The recommended CPU size for the Amazon ECS service.
	RecommendedCpuUnits int32

	//  The recommended memory size for the Amazon ECS service.
	RecommendedMemorySize int32

	noSmithyDocumentSerde
}

func (v *ECSServiceRecommendedOptionProjectedMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSServiceRecommendedOptionProjectedMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSServiceRecommendedOptionProjectedMetric) SerializeMembers(s smithy.ShapeSerializer) {
	serializeECSServiceProjectedMetrics(s, schemas.ECSServiceRecommendedOptionProjectedMetric_projectedMetrics, v.ProjectedMetrics)
	if v.RecommendedCpuUnits != 0 {
		s.WriteInt32(schemas.ECSServiceRecommendedOptionProjectedMetric_recommendedCpuUnits, v.RecommendedCpuUnits)
	}
	if v.RecommendedMemorySize != 0 {
		s.WriteInt32(schemas.ECSServiceRecommendedOptionProjectedMetric_recommendedMemorySize, v.RecommendedMemorySize)
	}
}
func (v *ECSServiceRecommendedOptionProjectedMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSServiceRecommendedOptionProjectedMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSServiceRecommendedOptionProjectedMetric_projectedMetrics:
			return deserializeECSServiceProjectedMetrics(d, schemas.ECSServiceRecommendedOptionProjectedMetric_projectedMetrics, &v.ProjectedMetrics)
		case schemas.ECSServiceRecommendedOptionProjectedMetric_recommendedCpuUnits:
			return d.ReadInt32(schemas.ECSServiceRecommendedOptionProjectedMetric_recommendedCpuUnits, &v.RecommendedCpuUnits)
		case schemas.ECSServiceRecommendedOptionProjectedMetric_recommendedMemorySize:
			return d.ReadInt32(schemas.ECSServiceRecommendedOptionProjectedMetric_recommendedMemorySize, &v.RecommendedMemorySize)
		}
		return nil
	})
}

//	Describes the utilization metric of an Amazon ECS service.
//
// To determine the performance difference between your current Amazon ECS service
// and the recommended option, compare the utilization metric data of your service
// against its projected utilization metric data.
type ECSServiceUtilizationMetric struct {

	//  The name of the utilization metric.
	//
	// The following utilization metrics are available:
	//
	//   - Cpu — The amount of CPU capacity that's used in the service.
	//
	//   - Memory — The amount of memory that's used in the service.
	Name ECSServiceMetricName

	// The statistic of the utilization metric.
	//
	// The Compute Optimizer API, Command Line Interface (CLI), and SDKs return
	// utilization metrics using only the Maximum statistic, which is the highest
	// value observed during the specified period.
	//
	// The Compute Optimizer console displays graphs for some utilization metrics
	// using the Average statistic, which is the value of Sum / SampleCount during the
	// specified period. For more information, see [Viewing resource recommendations]in the Compute Optimizer User
	// Guide. You can also get averaged utilization metric data for your resources
	// using Amazon CloudWatch. For more information, see the [Amazon CloudWatch User Guide].
	//
	// [Viewing resource recommendations]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/viewing-recommendations.html
	// [Amazon CloudWatch User Guide]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html
	Statistic ECSServiceMetricStatistic

	//  The value of the utilization metric.
	Value float64

	noSmithyDocumentSerde
}

func (v *ECSServiceUtilizationMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ECSServiceUtilizationMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ECSServiceUtilizationMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.ECSServiceUtilizationMetric_name, string(v.Name))
	}
	if v.Statistic != "" {
		s.WriteString(schemas.ECSServiceUtilizationMetric_statistic, string(v.Statistic))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.ECSServiceUtilizationMetric_value, v.Value)
	}
}
func (v *ECSServiceUtilizationMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ECSServiceUtilizationMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.ECSServiceUtilizationMetric_name:
			var ev string
			if err := d.ReadString(schemas.ECSServiceUtilizationMetric_name, &ev); err != nil {
				return err
			}
			v.Name = ECSServiceMetricName(ev)
			return nil
		case schemas.ECSServiceUtilizationMetric_statistic:
			var ev string
			if err := d.ReadString(schemas.ECSServiceUtilizationMetric_statistic, &ev); err != nil {
				return err
			}
			v.Statistic = ECSServiceMetricStatistic(ev)
			return nil
		case schemas.ECSServiceUtilizationMetric_value:
			return d.ReadFloat64(schemas.ECSServiceUtilizationMetric_value, &v.Value)
		}
		return nil
	})
}

//	Describes the effective preferred resources that Compute Optimizer considers
//
// as rightsizing recommendation candidates.
//
// Compute Optimizer only supports Amazon EC2 instance types.
type EffectivePreferredResource struct {

	//  The expanded version of your preferred resource's include list.
	EffectiveIncludeList []string

	//  The list of preferred resources values that you want excluded from rightsizing
	// recommendation candidates.
	ExcludeList []string

	//  The list of preferred resource values that you want considered as rightsizing
	// recommendation candidates.
	IncludeList []string

	//  The name of the preferred resource list.
	Name PreferredResourceName

	noSmithyDocumentSerde
}

func (v *EffectivePreferredResource) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EffectivePreferredResource)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EffectivePreferredResource) SerializeMembers(s smithy.ShapeSerializer) {
	serializePreferredResourceValues(s, schemas.EffectivePreferredResource_effectiveIncludeList, v.EffectiveIncludeList)
	serializePreferredResourceValues(s, schemas.EffectivePreferredResource_excludeList, v.ExcludeList)
	serializePreferredResourceValues(s, schemas.EffectivePreferredResource_includeList, v.IncludeList)
	if v.Name != "" {
		s.WriteString(schemas.EffectivePreferredResource_name, string(v.Name))
	}
}
func (v *EffectivePreferredResource) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EffectivePreferredResource, func(s *smithy.Schema) error {
		switch s {
		case schemas.EffectivePreferredResource_effectiveIncludeList:
			return deserializePreferredResourceValues(d, schemas.EffectivePreferredResource_effectiveIncludeList, &v.EffectiveIncludeList)
		case schemas.EffectivePreferredResource_excludeList:
			return deserializePreferredResourceValues(d, schemas.EffectivePreferredResource_excludeList, &v.ExcludeList)
		case schemas.EffectivePreferredResource_includeList:
			return deserializePreferredResourceValues(d, schemas.EffectivePreferredResource_includeList, &v.IncludeList)
		case schemas.EffectivePreferredResource_name:
			var ev string
			if err := d.ReadString(schemas.EffectivePreferredResource_name, &ev); err != nil {
				return err
			}
			v.Name = PreferredResourceName(ev)
			return nil
		}
		return nil
	})
}

// Describes the effective recommendation preferences for a resource.
type EffectiveRecommendationPreferences struct {

	// Describes the CPU vendor and architecture for an instance or Auto Scaling group
	// recommendations.
	//
	// For example, when you specify AWS_ARM64 with:
	//
	//   - A GetEC2InstanceRecommendationsor GetAutoScalingGroupRecommendationsrequest, Compute Optimizer returns recommendations that consist of
	//   Graviton instance types only.
	//
	//   - A GetEC2RecommendationProjectedMetricsrequest, Compute Optimizer returns projected utilization metrics for
	//   Graviton instance type recommendations only.
	//
	//   - A ExportEC2InstanceRecommendationsor ExportAutoScalingGroupRecommendationsrequest, Compute Optimizer exports recommendations that consist of
	//   Graviton instance types only.
	CpuVendorArchitectures []CpuVendorArchitecture

	// Describes the activation status of the enhanced infrastructure metrics
	// preference.
	//
	// A status of Active confirms that the preference is applied in the latest
	// recommendation refresh, and a status of Inactive confirms that it's not yet
	// applied to recommendations.
	//
	// For more information, see [Enhanced infrastructure metrics] in the Compute Optimizer User Guide.
	//
	// [Enhanced infrastructure metrics]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/enhanced-infrastructure-metrics.html
	EnhancedInfrastructureMetrics EnhancedInfrastructureMetrics

	//  An object that describes the external metrics recommendation preference.
	//
	// If the preference is applied in the latest recommendation refresh, an object
	// with a valid source value appears in the response. If the preference isn't
	// applied to the recommendations already, then this object doesn't appear in the
	// response.
	ExternalMetricsPreference *ExternalMetricsPreference

	// Describes the activation status of the inferred workload types preference.
	//
	// A status of Active confirms that the preference is applied in the latest
	// recommendation refresh. A status of Inactive confirms that it's not yet applied
	// to recommendations.
	InferredWorkloadTypes InferredWorkloadTypesPreference

	//  The number of days the utilization metrics of the Amazon Web Services resource
	// are analyzed.
	LookBackPeriod LookBackPeriodPreference

	//  The resource type values that are considered as candidates when generating
	// rightsizing recommendations.
	PreferredResources []EffectivePreferredResource

	//  Describes the savings estimation mode applied for calculating savings
	// opportunity for a resource.
	SavingsEstimationMode *InstanceSavingsEstimationMode

	//  The resource’s CPU and memory utilization preferences, such as threshold and
	// headroom, that are used to generate rightsizing recommendations.
	//
	// This preference is only available for the Amazon EC2 instance resource type.
	UtilizationPreferences []UtilizationPreference

	noSmithyDocumentSerde
}

func (v *EffectiveRecommendationPreferences) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EffectiveRecommendationPreferences)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EffectiveRecommendationPreferences) SerializeMembers(s smithy.ShapeSerializer) {
	serializeCpuVendorArchitectures(s, schemas.EffectiveRecommendationPreferences_cpuVendorArchitectures, v.CpuVendorArchitectures)
	if v.EnhancedInfrastructureMetrics != "" {
		s.WriteString(schemas.EffectiveRecommendationPreferences_enhancedInfrastructureMetrics, string(v.EnhancedInfrastructureMetrics))
	}
	if v.ExternalMetricsPreference != nil {
		s.WriteStruct(schemas.EffectiveRecommendationPreferences_externalMetricsPreference)
		v.ExternalMetricsPreference.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.InferredWorkloadTypes != "" {
		s.WriteString(schemas.EffectiveRecommendationPreferences_inferredWorkloadTypes, string(v.InferredWorkloadTypes))
	}
	if v.LookBackPeriod != "" {
		s.WriteString(schemas.EffectiveRecommendationPreferences_lookBackPeriod, string(v.LookBackPeriod))
	}
	serializeEffectivePreferredResources(s, schemas.EffectiveRecommendationPreferences_preferredResources, v.PreferredResources)
	if v.SavingsEstimationMode != nil {
		s.WriteStruct(schemas.EffectiveRecommendationPreferences_savingsEstimationMode)
		v.SavingsEstimationMode.SerializeMembers(s)
		s.CloseStruct()
	}
	serializeUtilizationPreferences(s, schemas.EffectiveRecommendationPreferences_utilizationPreferences, v.UtilizationPreferences)
}
func (v *EffectiveRecommendationPreferences) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EffectiveRecommendationPreferences, func(s *smithy.Schema) error {
		switch s {
		case schemas.EffectiveRecommendationPreferences_cpuVendorArchitectures:
			return deserializeCpuVendorArchitectures(d, schemas.EffectiveRecommendationPreferences_cpuVendorArchitectures, &v.CpuVendorArchitectures)
		case schemas.EffectiveRecommendationPreferences_enhancedInfrastructureMetrics:
			var ev string
			if err := d.ReadString(schemas.EffectiveRecommendationPreferences_enhancedInfrastructureMetrics, &ev); err != nil {
				return err
			}
			v.EnhancedInfrastructureMetrics = EnhancedInfrastructureMetrics(ev)
			return nil
		case schemas.EffectiveRecommendationPreferences_externalMetricsPreference:
			v.ExternalMetricsPreference = &ExternalMetricsPreference{}
			return v.ExternalMetricsPreference.Deserialize(d)
		case schemas.EffectiveRecommendationPreferences_inferredWorkloadTypes:
			var ev string
			if err := d.ReadString(schemas.EffectiveRecommendationPreferences_inferredWorkloadTypes, &ev); err != nil {
				return err
			}
			v.InferredWorkloadTypes = InferredWorkloadTypesPreference(ev)
			return nil
		case schemas.EffectiveRecommendationPreferences_lookBackPeriod:
			var ev string
			if err := d.ReadString(schemas.EffectiveRecommendationPreferences_lookBackPeriod, &ev); err != nil {
				return err
			}
			v.LookBackPeriod = LookBackPeriodPreference(ev)
			return nil
		case schemas.EffectiveRecommendationPreferences_preferredResources:
			return deserializeEffectivePreferredResources(d, schemas.EffectiveRecommendationPreferences_preferredResources, &v.PreferredResources)
		case schemas.EffectiveRecommendationPreferences_savingsEstimationMode:
			v.SavingsEstimationMode = &InstanceSavingsEstimationMode{}
			return v.SavingsEstimationMode.Deserialize(d)
		case schemas.EffectiveRecommendationPreferences_utilizationPreferences:
			return deserializeUtilizationPreferences(d, schemas.EffectiveRecommendationPreferences_utilizationPreferences, &v.UtilizationPreferences)
		}
		return nil
	})
}

// Describes a filter that returns a more specific list of account enrollment
// statuses. Use this filter with the GetEnrollmentStatusesForOrganizationaction.
type EnrollmentFilter struct {

	// The name of the filter.
	//
	// Specify Status to return accounts with a specific enrollment status (for
	// example, Active ).
	Name EnrollmentFilterName

	// The value of the filter.
	//
	// The valid values are Active , Inactive , Pending , and Failed .
	Values []string

	noSmithyDocumentSerde
}

func (v *EnrollmentFilter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EnrollmentFilter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EnrollmentFilter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.EnrollmentFilter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.EnrollmentFilter_values, v.Values)
}
func (v *EnrollmentFilter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EnrollmentFilter, func(s *smithy.Schema) error {
		switch s {
		case schemas.EnrollmentFilter_name:
			var ev string
			if err := d.ReadString(schemas.EnrollmentFilter_name, &ev); err != nil {
				return err
			}
			v.Name = EnrollmentFilterName(ev)
			return nil
		case schemas.EnrollmentFilter_values:
			return deserializeFilterValues(d, schemas.EnrollmentFilter_values, &v.Values)
		}
		return nil
	})
}

// Describes the estimated monthly savings amount possible, based on On-Demand
// instance pricing, by adopting Compute Optimizer recommendations for a given
// resource.
//
// For more information, see [Estimated monthly savings and savings opportunities] in the Compute Optimizer User Guide.
//
// [Estimated monthly savings and savings opportunities]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/view-ec2-recommendations.html#ec2-savings-calculation
type EstimatedMonthlySavings struct {

	// The currency of the estimated monthly savings.
	Currency Currency

	// The value of the estimated monthly savings.
	Value float64

	noSmithyDocumentSerde
}

func (v *EstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.EstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *EstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.EstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.EstimatedMonthlySavings_value, v.Value)
	}
}
func (v *EstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.EstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.EstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.EstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.EstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

// Describes the destination of the recommendations export and metadata files.
type ExportDestination struct {

	// An object that describes the destination Amazon Simple Storage Service (Amazon
	// S3) bucket name and object keys of a recommendations export file, and its
	// associated metadata file.
	S3 *S3Destination

	noSmithyDocumentSerde
}

func (v *ExportDestination) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ExportDestination)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ExportDestination) SerializeMembers(s smithy.ShapeSerializer) {
	if v.S3 != nil {
		s.WriteStruct(schemas.ExportDestination_s3)
		v.S3.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *ExportDestination) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ExportDestination, func(s *smithy.Schema) error {
		switch s {
		case schemas.ExportDestination_s3:
			v.S3 = &S3Destination{}
			return v.S3.Deserialize(d)
		}
		return nil
	})
}

//	Describes the external metrics preferences for EC2 rightsizing
//
// recommendations.
type ExternalMetricsPreference struct {

	//  Contains the source options for external metrics preferences.
	Source ExternalMetricsSource

	noSmithyDocumentSerde
}

func (v *ExternalMetricsPreference) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ExternalMetricsPreference)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ExternalMetricsPreference) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Source != "" {
		s.WriteString(schemas.ExternalMetricsPreference_source, string(v.Source))
	}
}
func (v *ExternalMetricsPreference) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ExternalMetricsPreference, func(s *smithy.Schema) error {
		switch s {
		case schemas.ExternalMetricsPreference_source:
			var ev string
			if err := d.ReadString(schemas.ExternalMetricsPreference_source, &ev); err != nil {
				return err
			}
			v.Source = ExternalMetricsSource(ev)
			return nil
		}
		return nil
	})
}

//	Describes Compute Optimizer's integration status with your chosen external
//
// metric provider. For example, Datadog.
type ExternalMetricStatus struct {

	//  The status code for Compute Optimizer's integration with an external metrics
	// provider.
	StatusCode ExternalMetricStatusCode

	//  The reason for Compute Optimizer's integration status with your external
	// metric provider.
	StatusReason *string

	noSmithyDocumentSerde
}

func (v *ExternalMetricStatus) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ExternalMetricStatus)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ExternalMetricStatus) SerializeMembers(s smithy.ShapeSerializer) {
	if v.StatusCode != "" {
		s.WriteString(schemas.ExternalMetricStatus_statusCode, string(v.StatusCode))
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.ExternalMetricStatus_statusReason, *v.StatusReason)
	}
}
func (v *ExternalMetricStatus) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ExternalMetricStatus, func(s *smithy.Schema) error {
		switch s {
		case schemas.ExternalMetricStatus_statusCode:
			var ev string
			if err := d.ReadString(schemas.ExternalMetricStatus_statusCode, &ev); err != nil {
				return err
			}
			v.StatusCode = ExternalMetricStatusCode(ev)
			return nil
		case schemas.ExternalMetricStatus_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.ExternalMetricStatus_statusReason, v.StatusReason)
		}
		return nil
	})
}

// Describes a filter that returns a more specific list of recommendations. Use
// this filter with the GetAutoScalingGroupRecommendationsand GetEC2InstanceRecommendations actions.
//
// You can use EBSFilter with the GetEBSVolumeRecommendations action, LambdaFunctionRecommendationFilter with
// the GetLambdaFunctionRecommendationsaction, and JobFilter with the DescribeRecommendationExportJobs action.
type Filter struct {

	// The name of the filter.
	//
	// Specify Finding to return recommendations with a specific finding
	// classification. For example, Underprovisioned .
	//
	// Specify RecommendationSourceType to return recommendations of a specific
	// resource type. For example, Ec2Instance .
	//
	// Specify FindingReasonCodes to return recommendations with a specific finding
	// reason code. For example, CPUUnderprovisioned .
	//
	// Specify InferredWorkloadTypes to return recommendations of a specific inferred
	// workload. For example, Redis .
	//
	// You can filter your EC2 instance recommendations by tag:key and tag-key tags.
	//
	// A tag:key is a key and value combination of a tag assigned to your
	// recommendations. Use the tag key in the filter name and the tag value as the
	// filter value. For example, to find all recommendations that have a tag with the
	// key of Owner and the value of TeamA , specify tag:Owner for the filter name and
	// TeamA for the filter value.
	//
	// A tag-key is the key of a tag assigned to your recommendations. Use this filter
	// to find all of your recommendations that have a tag with a specific key. This
	// doesn’t consider the tag value. For example, you can find your recommendations
	// with a tag key value of Owner or without any tag keys assigned.
	Name FilterName

	// The value of the filter.
	//
	// The valid values for this parameter are as follows, depending on what you
	// specify for the name parameter and the resource type that you wish to filter
	// results for:
	//
	//   - Specify Optimized or NotOptimized if you specify the name parameter as
	//   Finding and you want to filter results for Auto Scaling groups.
	//
	//   - Specify Underprovisioned , Overprovisioned , or Optimized if you specify the
	//   name parameter as Finding and you want to filter results for EC2 instances.
	//
	//   - Specify Ec2Instance or AutoScalingGroup if you specify the name parameter as
	//   RecommendationSourceType .
	//
	//   - Specify one of the following options if you specify the name parameter as
	//   FindingReasonCodes :
	//
	//   - CPUOverprovisioned — The instance’s CPU configuration can be sized down
	//   while still meeting the performance requirements of your workload.
	//
	//   - CPUUnderprovisioned — The instance’s CPU configuration doesn't meet the
	//   performance requirements of your workload and there is an alternative instance
	//   type that provides better CPU performance.
	//
	//   - MemoryOverprovisioned — The instance’s memory configuration can be sized
	//   down while still meeting the performance requirements of your workload.
	//
	//   - MemoryUnderprovisioned — The instance’s memory configuration doesn't meet
	//   the performance requirements of your workload and there is an alternative
	//   instance type that provides better memory performance.
	//
	//   - EBSThroughputOverprovisioned — The instance’s EBS throughput configuration
	//   can be sized down while still meeting the performance requirements of your
	//   workload.
	//
	//   - EBSThroughputUnderprovisioned — The instance’s EBS throughput configuration
	//   doesn't meet the performance requirements of your workload and there is an
	//   alternative instance type that provides better EBS throughput performance.
	//
	//   - EBSIOPSOverprovisioned — The instance’s EBS IOPS configuration can be sized
	//   down while still meeting the performance requirements of your workload.
	//
	//   - EBSIOPSUnderprovisioned — The instance’s EBS IOPS configuration doesn't meet
	//   the performance requirements of your workload and there is an alternative
	//   instance type that provides better EBS IOPS performance.
	//
	//   - NetworkBandwidthOverprovisioned — The instance’s network bandwidth
	//   configuration can be sized down while still meeting the performance requirements
	//   of your workload.
	//
	//   - NetworkBandwidthUnderprovisioned — The instance’s network bandwidth
	//   configuration doesn't meet the performance requirements of your workload and
	//   there is an alternative instance type that provides better network bandwidth
	//   performance. This finding reason happens when the NetworkIn or NetworkOut
	//   performance of an instance is impacted.
	//
	//   - NetworkPPSOverprovisioned — The instance’s network PPS (packets per second)
	//   configuration can be sized down while still meeting the performance requirements
	//   of your workload.
	//
	//   - NetworkPPSUnderprovisioned — The instance’s network PPS (packets per second)
	//   configuration doesn't meet the performance requirements of your workload and
	//   there is an alternative instance type that provides better network PPS
	//   performance.
	//
	//   - DiskIOPSOverprovisioned — The instance’s disk IOPS configuration can be
	//   sized down while still meeting the performance requirements of your workload.
	//
	//   - DiskIOPSUnderprovisioned — The instance’s disk IOPS configuration doesn't
	//   meet the performance requirements of your workload and there is an alternative
	//   instance type that provides better disk IOPS performance.
	//
	//   - DiskThroughputOverprovisioned — The instance’s disk throughput configuration
	//   can be sized down while still meeting the performance requirements of your
	//   workload.
	//
	//   - DiskThroughputUnderprovisioned — The instance’s disk throughput
	//   configuration doesn't meet the performance requirements of your workload and
	//   there is an alternative instance type that provides better disk throughput
	//   performance.
	Values []string

	noSmithyDocumentSerde
}

func (v *Filter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.Filter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *Filter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.Filter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.Filter_values, v.Values)
}
func (v *Filter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Filter, func(s *smithy.Schema) error {
		switch s {
		case schemas.Filter_name:
			var ev string
			if err := d.ReadString(schemas.Filter_name, &ev); err != nil {
				return err
			}
			v.Name = FilterName(ev)
			return nil
		case schemas.Filter_values:
			return deserializeFilterValues(d, schemas.Filter_values, &v.Values)
		}
		return nil
	})
}

// Describes an error experienced when getting recommendations.
//
// For example, an error is returned if you request recommendations for an
// unsupported Auto Scaling group, or if you request recommendations for an
// instance of an unsupported instance family.
type GetRecommendationError struct {

	// The error code.
	Code *string

	// The ID of the error.
	Identifier *string

	// The message, or reason, for the error.
	Message *string

	noSmithyDocumentSerde
}

func (v *GetRecommendationError) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.GetRecommendationError)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *GetRecommendationError) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Code != nil {
		s.WriteString(schemas.GetRecommendationError_code, *v.Code)
	}
	if v.Identifier != nil {
		s.WriteString(schemas.GetRecommendationError_identifier, *v.Identifier)
	}
	if v.Message != nil {
		s.WriteString(schemas.GetRecommendationError_message, *v.Message)
	}
}
func (v *GetRecommendationError) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.GetRecommendationError, func(s *smithy.Schema) error {
		switch s {
		case schemas.GetRecommendationError_code:
			v.Code = new(string)
			return d.ReadString(schemas.GetRecommendationError_code, v.Code)
		case schemas.GetRecommendationError_identifier:
			v.Identifier = new(string)
			return d.ReadString(schemas.GetRecommendationError_identifier, v.Identifier)
		case schemas.GetRecommendationError_message:
			v.Message = new(string)
			return d.ReadString(schemas.GetRecommendationError_message, v.Message)
		}
		return nil
	})
}

// Describes the GPU accelerators for the instance type.
type Gpu struct {

	//  The number of GPUs for the instance type.
	GpuCount int32

	//  The total size of the memory for the GPU accelerators for the instance type,
	// in MiB.
	GpuMemorySizeInMiB int32

	noSmithyDocumentSerde
}

func (v *Gpu) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.Gpu)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *Gpu) SerializeMembers(s smithy.ShapeSerializer) {
	if v.GpuCount != 0 {
		s.WriteInt32(schemas.Gpu_gpuCount, v.GpuCount)
	}
	if v.GpuMemorySizeInMiB != 0 {
		s.WriteInt32(schemas.Gpu_gpuMemorySizeInMiB, v.GpuMemorySizeInMiB)
	}
}
func (v *Gpu) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Gpu, func(s *smithy.Schema) error {
		switch s {
		case schemas.Gpu_gpuCount:
			return d.ReadInt32(schemas.Gpu_gpuCount, &v.GpuCount)
		case schemas.Gpu_gpuMemorySizeInMiB:
			return d.ReadInt32(schemas.Gpu_gpuMemorySizeInMiB, &v.GpuMemorySizeInMiB)
		}
		return nil
	})
}

// Describes the GPU accelerator settings for the instance type.
type GpuInfo struct {

	//  Describes the GPU accelerators for the instance type.
	Gpus []Gpu

	noSmithyDocumentSerde
}

func (v *GpuInfo) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.GpuInfo)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *GpuInfo) SerializeMembers(s smithy.ShapeSerializer) {
	serializeGpus(s, schemas.GpuInfo_gpus, v.Gpus)
}
func (v *GpuInfo) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.GpuInfo, func(s *smithy.Schema) error {
		switch s {
		case schemas.GpuInfo_gpus:
			return deserializeGpus(d, schemas.GpuInfo_gpus, &v.Gpus)
		}
		return nil
	})
}

// Describes the dimension of an idle resource utilization metric.
type IdleDimension struct {

	// The name of the dimension key.
	Key *string

	// The value of the dimension.
	Values []string

	noSmithyDocumentSerde
}

func (v *IdleDimension) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleDimension)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleDimension) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Key != nil {
		s.WriteString(schemas.IdleDimension_key, *v.Key)
	}
	serializeIdleDimensionValues(s, schemas.IdleDimension_values, v.Values)
}
func (v *IdleDimension) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleDimension, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleDimension_key:
			v.Key = new(string)
			return d.ReadString(schemas.IdleDimension_key, v.Key)
		case schemas.IdleDimension_values:
			return deserializeIdleDimensionValues(d, schemas.IdleDimension_values, &v.Values)
		}
		return nil
	})
}

// Describes the estimated monthly savings possible for idle resources by adopting
// Compute Optimizer recommendations.
type IdleEstimatedMonthlySavings struct {

	// The currency of the estimated monthly savings.
	Currency Currency

	// The value of the estimated monthly savings for Idle resources.
	Value float64

	noSmithyDocumentSerde
}

func (v *IdleEstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleEstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleEstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.IdleEstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.IdleEstimatedMonthlySavings_value, v.Value)
	}
}
func (v *IdleEstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleEstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleEstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.IdleEstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.IdleEstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.IdleEstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

// Describes an Idle resource recommendation.
type IdleRecommendation struct {

	// The Amazon Web Services account ID of the idle resource.
	AccountId *string

	// The finding classification of an idle resource.
	Finding IdleFinding

	// A summary of the findings for the resource.
	FindingDescription *string

	// The timestamp of when the idle resource recommendation was last generated.
	LastRefreshTimestamp *time.Time

	// The number of days the idle resource utilization metrics were analyzed.
	LookBackPeriodInDays float64

	// The ARN of the current idle resource.
	ResourceArn *string

	// The unique identifier for the resource.
	ResourceId *string

	// The type of resource that is idle.
	ResourceType IdleRecommendationResourceType

	// The savings opportunity for the idle resource.
	SavingsOpportunity *IdleSavingsOpportunity

	// The savings opportunity for the idle resource after any applying discounts.
	SavingsOpportunityAfterDiscounts *IdleSavingsOpportunityAfterDiscounts

	// A list of tags assigned to your idle resource recommendations.
	Tags []Tag

	// An array of objects that describe the utilization metrics of the idle resource.
	UtilizationMetrics []IdleUtilizationMetric

	noSmithyDocumentSerde
}

func (v *IdleRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.IdleRecommendation_accountId, *v.AccountId)
	}
	if v.Finding != "" {
		s.WriteString(schemas.IdleRecommendation_finding, string(v.Finding))
	}
	if v.FindingDescription != nil {
		s.WriteString(schemas.IdleRecommendation_findingDescription, *v.FindingDescription)
	}
	if v.LastRefreshTimestamp != nil {
		s.WriteTime(schemas.IdleRecommendation_lastRefreshTimestamp, *v.LastRefreshTimestamp)
	}
	if v.LookBackPeriodInDays != 0 {
		s.WriteFloat64(schemas.IdleRecommendation_lookBackPeriodInDays, v.LookBackPeriodInDays)
	}
	if v.ResourceArn != nil {
		s.WriteString(schemas.IdleRecommendation_resourceArn, *v.ResourceArn)
	}
	if v.ResourceId != nil {
		s.WriteString(schemas.IdleRecommendation_resourceId, *v.ResourceId)
	}
	if v.ResourceType != "" {
		s.WriteString(schemas.IdleRecommendation_resourceType, string(v.ResourceType))
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.IdleRecommendation_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityAfterDiscounts != nil {
		s.WriteStruct(schemas.IdleRecommendation_savingsOpportunityAfterDiscounts)
		v.SavingsOpportunityAfterDiscounts.SerializeMembers(s)
		s.CloseStruct()
	}
	serializeTags(s, schemas.IdleRecommendation_tags, v.Tags)
	serializeIdleUtilizationMetrics(s, schemas.IdleRecommendation_utilizationMetrics, v.UtilizationMetrics)
}
func (v *IdleRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleRecommendation_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.IdleRecommendation_accountId, v.AccountId)
		case schemas.IdleRecommendation_finding:
			var ev string
			if err := d.ReadString(schemas.IdleRecommendation_finding, &ev); err != nil {
				return err
			}
			v.Finding = IdleFinding(ev)
			return nil
		case schemas.IdleRecommendation_findingDescription:
			v.FindingDescription = new(string)
			return d.ReadString(schemas.IdleRecommendation_findingDescription, v.FindingDescription)
		case schemas.IdleRecommendation_lastRefreshTimestamp:
			v.LastRefreshTimestamp = new(time.Time)
			return d.ReadTime(schemas.IdleRecommendation_lastRefreshTimestamp, v.LastRefreshTimestamp)
		case schemas.IdleRecommendation_lookBackPeriodInDays:
			return d.ReadFloat64(schemas.IdleRecommendation_lookBackPeriodInDays, &v.LookBackPeriodInDays)
		case schemas.IdleRecommendation_resourceArn:
			v.ResourceArn = new(string)
			return d.ReadString(schemas.IdleRecommendation_resourceArn, v.ResourceArn)
		case schemas.IdleRecommendation_resourceId:
			v.ResourceId = new(string)
			return d.ReadString(schemas.IdleRecommendation_resourceId, v.ResourceId)
		case schemas.IdleRecommendation_resourceType:
			var ev string
			if err := d.ReadString(schemas.IdleRecommendation_resourceType, &ev); err != nil {
				return err
			}
			v.ResourceType = IdleRecommendationResourceType(ev)
			return nil
		case schemas.IdleRecommendation_savingsOpportunity:
			v.SavingsOpportunity = &IdleSavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.IdleRecommendation_savingsOpportunityAfterDiscounts:
			v.SavingsOpportunityAfterDiscounts = &IdleSavingsOpportunityAfterDiscounts{}
			return v.SavingsOpportunityAfterDiscounts.Deserialize(d)
		case schemas.IdleRecommendation_tags:
			return deserializeTags(d, schemas.IdleRecommendation_tags, &v.Tags)
		case schemas.IdleRecommendation_utilizationMetrics:
			return deserializeIdleUtilizationMetrics(d, schemas.IdleRecommendation_utilizationMetrics, &v.UtilizationMetrics)
		}
		return nil
	})
}

// Returns of list of resources that doesn't have idle recommendations.
type IdleRecommendationError struct {

	// The error code.
	Code *string

	// The ID of the error.
	Identifier *string

	// The error message.
	Message *string

	// The type of resource associated with the error.
	ResourceType IdleRecommendationResourceType

	noSmithyDocumentSerde
}

func (v *IdleRecommendationError) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleRecommendationError)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleRecommendationError) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Code != nil {
		s.WriteString(schemas.IdleRecommendationError_code, *v.Code)
	}
	if v.Identifier != nil {
		s.WriteString(schemas.IdleRecommendationError_identifier, *v.Identifier)
	}
	if v.Message != nil {
		s.WriteString(schemas.IdleRecommendationError_message, *v.Message)
	}
	if v.ResourceType != "" {
		s.WriteString(schemas.IdleRecommendationError_resourceType, string(v.ResourceType))
	}
}
func (v *IdleRecommendationError) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleRecommendationError, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleRecommendationError_code:
			v.Code = new(string)
			return d.ReadString(schemas.IdleRecommendationError_code, v.Code)
		case schemas.IdleRecommendationError_identifier:
			v.Identifier = new(string)
			return d.ReadString(schemas.IdleRecommendationError_identifier, v.Identifier)
		case schemas.IdleRecommendationError_message:
			v.Message = new(string)
			return d.ReadString(schemas.IdleRecommendationError_message, v.Message)
		case schemas.IdleRecommendationError_resourceType:
			var ev string
			if err := d.ReadString(schemas.IdleRecommendationError_resourceType, &ev); err != nil {
				return err
			}
			v.ResourceType = IdleRecommendationResourceType(ev)
			return nil
		}
		return nil
	})
}

// Describes a filter that returns a more specific list of idle resource
// recommendations.
type IdleRecommendationFilter struct {

	//  The name of the filter.
	//
	// Specify Finding to return recommendations with a specific finding
	// classification.
	//
	// You can filter your idle resource recommendations by tag:key and tag-key tags.
	//
	// A tag:key is a key and value combination of a tag assigned to your idle
	// resource recommendations. Use the tag key in the filter name and the tag value
	// as the filter value. For example, to find all idle resource service
	// recommendations that have a tag with the key of Owner and the value of TeamA ,
	// specify tag:Owner for the filter name and TeamA for the filter value.
	//
	// A tag-key is the key of a tag assigned to your idle resource recommendations.
	// Use this filter to find all of your idle resource recommendations that have a
	// tag with a specific key. This doesn’t consider the tag value. For example, you
	// can find your idle resource service recommendations with a tag key value of
	// Owner or without any tag keys assigned.
	Name IdleRecommendationFilterName

	// The value of the filter.
	Values []string

	noSmithyDocumentSerde
}

func (v *IdleRecommendationFilter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleRecommendationFilter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleRecommendationFilter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.IdleRecommendationFilter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.IdleRecommendationFilter_values, v.Values)
}
func (v *IdleRecommendationFilter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleRecommendationFilter, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleRecommendationFilter_name:
			var ev string
			if err := d.ReadString(schemas.IdleRecommendationFilter_name, &ev); err != nil {
				return err
			}
			v.Name = IdleRecommendationFilterName(ev)
			return nil
		case schemas.IdleRecommendationFilter_values:
			return deserializeFilterValues(d, schemas.IdleRecommendationFilter_values, &v.Values)
		}
		return nil
	})
}

// Describes the savings opportunity for idle resource recommendations.
type IdleSavingsOpportunity struct {

	// The estimated monthly savings possible by adopting Compute Optimizer's idle
	// resource recommendations.
	EstimatedMonthlySavings *IdleEstimatedMonthlySavings

	// The estimated monthly savings possible as a percentage of monthly cost by
	// adopting Compute Optimizer's idle resource recommendations.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *IdleSavingsOpportunity) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleSavingsOpportunity)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleSavingsOpportunity) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.IdleSavingsOpportunity_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.IdleSavingsOpportunity_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *IdleSavingsOpportunity) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleSavingsOpportunity, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleSavingsOpportunity_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &IdleEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.IdleSavingsOpportunity_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.IdleSavingsOpportunity_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

// Describes the savings opportunity for idle resource recommendations after
// applying discounts.
//
// Savings opportunity represents the estimated monthly savings after applying
// discounts. You can achieve this by implementing a given Compute Optimizer
// recommendation.
type IdleSavingsOpportunityAfterDiscounts struct {

	// The estimated monthly savings possible by adopting Compute Optimizer's idle
	// resource recommendations. This includes any applicable discounts.
	EstimatedMonthlySavings *IdleEstimatedMonthlySavings

	// The estimated monthly savings possible as a percentage of monthly cost by
	// adopting Compute Optimizer's idle resource recommendations. This includes any
	// applicable discounts.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *IdleSavingsOpportunityAfterDiscounts) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleSavingsOpportunityAfterDiscounts)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleSavingsOpportunityAfterDiscounts) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.IdleSavingsOpportunityAfterDiscounts_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.IdleSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *IdleSavingsOpportunityAfterDiscounts) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleSavingsOpportunityAfterDiscounts, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleSavingsOpportunityAfterDiscounts_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &IdleEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.IdleSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.IdleSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

// Describes the findings summary of the idle resources.
type IdleSummary struct {

	// The name of the finding group for the idle resources.
	Name IdleFinding

	// The count of idle resources in the finding group.
	Value float64

	noSmithyDocumentSerde
}

func (v *IdleSummary) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleSummary)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.IdleSummary_name, string(v.Name))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.IdleSummary_value, v.Value)
	}
}
func (v *IdleSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleSummary_name:
			var ev string
			if err := d.ReadString(schemas.IdleSummary_name, &ev); err != nil {
				return err
			}
			v.Name = IdleFinding(ev)
			return nil
		case schemas.IdleSummary_value:
			return d.ReadFloat64(schemas.IdleSummary_value, &v.Value)
		}
		return nil
	})
}

// Describes the utilization metric of an idle resource.
type IdleUtilizationMetric struct {

	// The dimensions of the utilization metric.
	Dimensions []IdleDimension

	// The name of the utilization metric.
	Name IdleMetricName

	//  The statistic of the utilization metric.
	//
	// The Compute Optimizer API, Command Line Interface (CLI), and SDKs return
	// utilization metrics using only the Maximum statistic, which is the highest
	// value observed during the specified period.
	//
	// The Compute Optimizer console displays graphs for some utilization metrics
	// using the Average statistic, which is the value of Sum / SampleCount during the
	// specified period. For more information, see [Viewing resource recommendations]in the Compute Optimizer User
	// Guide. You can also get averaged utilization metric data for your resources
	// using Amazon CloudWatch. For more information, see the [Amazon CloudWatch User Guide].
	//
	// [Viewing resource recommendations]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/viewing-recommendations.html
	// [Amazon CloudWatch User Guide]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html
	Statistic MetricStatistic

	// The value of the utilization metric.
	Value float64

	noSmithyDocumentSerde
}

func (v *IdleUtilizationMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.IdleUtilizationMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *IdleUtilizationMetric) SerializeMembers(s smithy.ShapeSerializer) {
	serializeIdleDimensions(s, schemas.IdleUtilizationMetric_dimensions, v.Dimensions)
	if v.Name != "" {
		s.WriteString(schemas.IdleUtilizationMetric_name, string(v.Name))
	}
	if v.Statistic != "" {
		s.WriteString(schemas.IdleUtilizationMetric_statistic, string(v.Statistic))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.IdleUtilizationMetric_value, v.Value)
	}
}
func (v *IdleUtilizationMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.IdleUtilizationMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.IdleUtilizationMetric_dimensions:
			return deserializeIdleDimensions(d, schemas.IdleUtilizationMetric_dimensions, &v.Dimensions)
		case schemas.IdleUtilizationMetric_name:
			var ev string
			if err := d.ReadString(schemas.IdleUtilizationMetric_name, &ev); err != nil {
				return err
			}
			v.Name = IdleMetricName(ev)
			return nil
		case schemas.IdleUtilizationMetric_statistic:
			var ev string
			if err := d.ReadString(schemas.IdleUtilizationMetric_statistic, &ev); err != nil {
				return err
			}
			v.Statistic = MetricStatistic(ev)
			return nil
		case schemas.IdleUtilizationMetric_value:
			return d.ReadFloat64(schemas.IdleUtilizationMetric_value, &v.Value)
		}
		return nil
	})
}

//	The estimated monthly savings after you adjust the configurations of your
//
// instances running on the inferred workload types to the recommended
// configurations. If the inferredWorkloadTypes list contains multiple entries,
// then the savings are the sum of the monthly savings from instances that run the
// exact combination of the inferred workload types.
type InferredWorkloadSaving struct {

	// An object that describes the estimated monthly savings amount possible by
	// adopting Compute Optimizer recommendations for a given resource. This is based
	// on the On-Demand instance pricing.
	EstimatedMonthlySavings *EstimatedMonthlySavings

	// The applications that might be running on the instance as inferred by Compute
	// Optimizer.
	//
	// Compute Optimizer can infer if one of the following applications might be
	// running on the instance:
	//
	//   - AmazonEmr - Infers that Amazon EMR might be running on the instance.
	//
	//   - ApacheCassandra - Infers that Apache Cassandra might be running on the
	//   instance.
	//
	//   - ApacheHadoop - Infers that Apache Hadoop might be running on the instance.
	//
	//   - Memcached - Infers that Memcached might be running on the instance.
	//
	//   - NGINX - Infers that NGINX might be running on the instance.
	//
	//   - PostgreSql - Infers that PostgreSQL might be running on the instance.
	//
	//   - Redis - Infers that Redis might be running on the instance.
	//
	//   - Kafka - Infers that Kafka might be running on the instance.
	//
	//   - SQLServer - Infers that SQLServer might be running on the instance.
	InferredWorkloadTypes []InferredWorkloadType

	noSmithyDocumentSerde
}

func (v *InferredWorkloadSaving) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.InferredWorkloadSaving)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *InferredWorkloadSaving) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.InferredWorkloadSaving_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	serializeInferredWorkloadTypes(s, schemas.InferredWorkloadSaving_inferredWorkloadTypes, v.InferredWorkloadTypes)
}
func (v *InferredWorkloadSaving) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InferredWorkloadSaving, func(s *smithy.Schema) error {
		switch s {
		case schemas.InferredWorkloadSaving_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &EstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.InferredWorkloadSaving_inferredWorkloadTypes:
			return deserializeInferredWorkloadTypes(d, schemas.InferredWorkloadSaving_inferredWorkloadTypes, &v.InferredWorkloadTypes)
		}
		return nil
	})
}

//	An object that describes the estimated monthly savings possible by adopting
//
// Compute Optimizer’s Amazon EC2 instance recommendations. This is based on the
// Savings Plans and Reserved Instances pricing discounts.
type InstanceEstimatedMonthlySavings struct {

	//  The currency of the estimated monthly savings.
	Currency Currency

	//  The value of the estimated monthly savings.
	Value float64

	noSmithyDocumentSerde
}

func (v *InstanceEstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.InstanceEstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *InstanceEstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.InstanceEstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.InstanceEstimatedMonthlySavings_value, v.Value)
	}
}
func (v *InstanceEstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InstanceEstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.InstanceEstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.InstanceEstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.InstanceEstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.InstanceEstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

// Describes an Amazon EC2 instance recommendation.
type InstanceRecommendation struct {

	// The Amazon Web Services account ID of the instance.
	AccountId *string

	//  Describes the GPU accelerator settings for the current instance type.
	CurrentInstanceGpuInfo *GpuInfo

	// The instance type of the current instance.
	CurrentInstanceType *string

	// The risk of the current instance not meeting the performance needs of its
	// workloads. The higher the risk, the more likely the current instance cannot meet
	// the performance requirements of its workload.
	CurrentPerformanceRisk CurrentPerformanceRisk

	// An object that describes the effective recommendation preferences for the
	// instance.
	EffectiveRecommendationPreferences *EffectiveRecommendationPreferences

	//  An object that describes Compute Optimizer's integration status with your
	// external metrics provider.
	ExternalMetricStatus *ExternalMetricStatus

	// The finding classification of the instance.
	//
	// Findings for instances include:
	//
	//   - Underprovisioned —An instance is considered under-provisioned when at least
	//   one specification of your instance, such as CPU, memory, or network, does not
	//   meet the performance requirements of your workload. Under-provisioned instances
	//   may lead to poor application performance.
	//
	//   - Overprovisioned —An instance is considered over-provisioned when at least
	//   one specification of your instance, such as CPU, memory, or network, can be
	//   sized down while still meeting the performance requirements of your workload,
	//   and no specification is under-provisioned. Over-provisioned instances may lead
	//   to unnecessary infrastructure cost.
	//
	//   - Optimized —An instance is considered optimized when all specifications of
	//   your instance, such as CPU, memory, and network, meet the performance
	//   requirements of your workload and is not over provisioned. For optimized
	//   resources, Compute Optimizer might recommend a new generation instance type.
	//
	// The valid values in your API responses appear as OVER_PROVISIONED,
	// UNDER_PROVISIONED, or OPTIMIZED.
	Finding Finding

	// The reason for the finding classification of the instance.
	//
	// Finding reason codes for instances include:
	//
	//   - CPUOverprovisioned — The instance’s CPU configuration can be sized down
	//   while still meeting the performance requirements of your workload. This is
	//   identified by analyzing the CPUUtilization metric of the current instance
	//   during the look-back period.
	//
	//   - CPUUnderprovisioned — The instance’s CPU configuration doesn't meet the
	//   performance requirements of your workload and there is an alternative instance
	//   type that provides better CPU performance. This is identified by analyzing the
	//   CPUUtilization metric of the current instance during the look-back period.
	//
	//   - MemoryOverprovisioned — The instance’s memory configuration can be sized
	//   down while still meeting the performance requirements of your workload. This is
	//   identified by analyzing the memory utilization metric of the current instance
	//   during the look-back period.
	//
	//   - MemoryUnderprovisioned — The instance’s memory configuration doesn't meet
	//   the performance requirements of your workload and there is an alternative
	//   instance type that provides better memory performance. This is identified by
	//   analyzing the memory utilization metric of the current instance during the
	//   look-back period.
	//
	// Memory utilization is analyzed only for resources that have the unified
	//   CloudWatch agent installed on them. For more information, see [Enabling memory utilization with the Amazon CloudWatch Agent]in the Compute
	//   Optimizer User Guide. On Linux instances, Compute Optimizer analyses the
	//   mem_used_percent metric in the CWAgent namespace, or the legacy
	//   MemoryUtilization metric in the System/Linux namespace. On Windows instances,
	//   Compute Optimizer analyses the Memory % Committed Bytes In Use metric in the
	//   CWAgent namespace.
	//
	//   - EBSThroughputOverprovisioned — The instance’s EBS throughput configuration
	//   can be sized down while still meeting the performance requirements of your
	//   workload. This is identified by analyzing the VolumeReadBytes and
	//   VolumeWriteBytes metrics of EBS volumes attached to the current instance
	//   during the look-back period.
	//
	//   - EBSThroughputUnderprovisioned — The instance’s EBS throughput configuration
	//   doesn't meet the performance requirements of your workload and there is an
	//   alternative instance type that provides better EBS throughput performance. This
	//   is identified by analyzing the VolumeReadBytes and VolumeWriteBytes metrics of
	//   EBS volumes attached to the current instance during the look-back period.
	//
	//   - EBSIOPSOverprovisioned — The instance’s EBS IOPS configuration can be sized
	//   down while still meeting the performance requirements of your workload. This is
	//   identified by analyzing the VolumeReadOps and VolumeWriteOps metric of EBS
	//   volumes attached to the current instance during the look-back period.
	//
	//   - EBSIOPSUnderprovisioned — The instance’s EBS IOPS configuration doesn't meet
	//   the performance requirements of your workload and there is an alternative
	//   instance type that provides better EBS IOPS performance. This is identified by
	//   analyzing the VolumeReadOps and VolumeWriteOps metric of EBS volumes attached
	//   to the current instance during the look-back period.
	//
	//   - NetworkBandwidthOverprovisioned — The instance’s network bandwidth
	//   configuration can be sized down while still meeting the performance requirements
	//   of your workload. This is identified by analyzing the NetworkIn and NetworkOut
	//   metrics of the current instance during the look-back period.
	//
	//   - NetworkBandwidthUnderprovisioned — The instance’s network bandwidth
	//   configuration doesn't meet the performance requirements of your workload and
	//   there is an alternative instance type that provides better network bandwidth
	//   performance. This is identified by analyzing the NetworkIn and NetworkOut
	//   metrics of the current instance during the look-back period. This finding reason
	//   happens when the NetworkIn or NetworkOut performance of an instance is
	//   impacted.
	//
	//   - NetworkPPSOverprovisioned — The instance’s network PPS (packets per second)
	//   configuration can be sized down while still meeting the performance requirements
	//   of your workload. This is identified by analyzing the NetworkPacketsIn and
	//   NetworkPacketsIn metrics of the current instance during the look-back period.
	//
	//   - NetworkPPSUnderprovisioned — The instance’s network PPS (packets per second)
	//   configuration doesn't meet the performance requirements of your workload and
	//   there is an alternative instance type that provides better network PPS
	//   performance. This is identified by analyzing the NetworkPacketsIn and
	//   NetworkPacketsIn metrics of the current instance during the look-back period.
	//
	//   - DiskIOPSOverprovisioned — The instance’s disk IOPS configuration can be
	//   sized down while still meeting the performance requirements of your workload.
	//   This is identified by analyzing the DiskReadOps and DiskWriteOps metrics of
	//   the current instance during the look-back period.
	//
	//   - DiskIOPSUnderprovisioned — The instance’s disk IOPS configuration doesn't
	//   meet the performance requirements of your workload and there is an alternative
	//   instance type that provides better disk IOPS performance. This is identified by
	//   analyzing the DiskReadOps and DiskWriteOps metrics of the current instance
	//   during the look-back period.
	//
	//   - DiskThroughputOverprovisioned — The instance’s disk throughput configuration
	//   can be sized down while still meeting the performance requirements of your
	//   workload. This is identified by analyzing the DiskReadBytes and DiskWriteBytes
	//   metrics of the current instance during the look-back period.
	//
	//   - DiskThroughputUnderprovisioned — The instance’s disk throughput
	//   configuration doesn't meet the performance requirements of your workload and
	//   there is an alternative instance type that provides better disk throughput
	//   performance. This is identified by analyzing the DiskReadBytes and
	//   DiskWriteBytes metrics of the current instance during the look-back period.
	//
	// For more information about instance metrics, see [List the available CloudWatch metrics for your instances] in the Amazon Elastic Compute
	// Cloud User Guide. For more information about EBS volume metrics, see [Amazon CloudWatch metrics for Amazon EBS]in the
	// Amazon Elastic Compute Cloud User Guide.
	//
	// [Enabling memory utilization with the Amazon CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#cw-agent
	// [Amazon CloudWatch metrics for Amazon EBS]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using_cloudwatch_ebs.html
	// [List the available CloudWatch metrics for your instances]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/viewing_metrics_with_cloudwatch.html
	FindingReasonCodes []InstanceRecommendationFindingReasonCode

	//  Describes if an Amazon EC2 instance is idle.
	Idle InstanceIdle

	// The applications that might be running on the instance as inferred by Compute
	// Optimizer.
	//
	// Compute Optimizer can infer if one of the following applications might be
	// running on the instance:
	//
	//   - AmazonEmr - Infers that Amazon EMR might be running on the instance.
	//
	//   - ApacheCassandra - Infers that Apache Cassandra might be running on the
	//   instance.
	//
	//   - ApacheHadoop - Infers that Apache Hadoop might be running on the instance.
	//
	//   - Memcached - Infers that Memcached might be running on the instance.
	//
	//   - NGINX - Infers that NGINX might be running on the instance.
	//
	//   - PostgreSql - Infers that PostgreSQL might be running on the instance.
	//
	//   - Redis - Infers that Redis might be running on the instance.
	//
	//   - Kafka - Infers that Kafka might be running on the instance.
	//
	//   - SQLServer - Infers that SQLServer might be running on the instance.
	InferredWorkloadTypes []InferredWorkloadType

	// The Amazon Resource Name (ARN) of the current instance.
	InstanceArn *string

	// The name of the current instance.
	InstanceName *string

	//  The state of the instance when the recommendation was generated.
	InstanceState InstanceState

	// The timestamp of when the instance recommendation was last generated.
	LastRefreshTimestamp *time.Time

	// The number of days for which utilization metrics were analyzed for the instance.
	LookBackPeriodInDays float64

	// An array of objects that describe the recommendation options for the instance.
	RecommendationOptions []InstanceRecommendationOption

	// An array of objects that describe the source resource of the recommendation.
	RecommendationSources []RecommendationSource

	//  A list of tags assigned to your Amazon EC2 instance recommendations.
	Tags []Tag

	// An array of objects that describe the utilization metrics of the instance.
	UtilizationMetrics []UtilizationMetric

	noSmithyDocumentSerde
}

func (v *InstanceRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.InstanceRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *InstanceRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.InstanceRecommendation_accountId, *v.AccountId)
	}
	if v.CurrentInstanceGpuInfo != nil {
		s.WriteStruct(schemas.InstanceRecommendation_currentInstanceGpuInfo)
		v.CurrentInstanceGpuInfo.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CurrentInstanceType != nil {
		s.WriteString(schemas.InstanceRecommendation_currentInstanceType, *v.CurrentInstanceType)
	}
	if v.CurrentPerformanceRisk != "" {
		s.WriteString(schemas.InstanceRecommendation_currentPerformanceRisk, string(v.CurrentPerformanceRisk))
	}
	if v.EffectiveRecommendationPreferences != nil {
		s.WriteStruct(schemas.InstanceRecommendation_effectiveRecommendationPreferences)
		v.EffectiveRecommendationPreferences.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ExternalMetricStatus != nil {
		s.WriteStruct(schemas.InstanceRecommendation_externalMetricStatus)
		v.ExternalMetricStatus.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Finding != "" {
		s.WriteString(schemas.InstanceRecommendation_finding, string(v.Finding))
	}
	serializeInstanceRecommendationFindingReasonCodes(s, schemas.InstanceRecommendation_findingReasonCodes, v.FindingReasonCodes)
	if v.Idle != "" {
		s.WriteString(schemas.InstanceRecommendation_idle, string(v.Idle))
	}
	serializeInferredWorkloadTypes(s, schemas.InstanceRecommendation_inferredWorkloadTypes, v.InferredWorkloadTypes)
	if v.InstanceArn != nil {
		s.WriteString(schemas.InstanceRecommendation_instanceArn, *v.InstanceArn)
	}
	if v.InstanceName != nil {
		s.WriteString(schemas.InstanceRecommendation_instanceName, *v.InstanceName)
	}
	if v.InstanceState != "" {
		s.WriteString(schemas.InstanceRecommendation_instanceState, string(v.InstanceState))
	}
	if v.LastRefreshTimestamp != nil {
		s.WriteTime(schemas.InstanceRecommendation_lastRefreshTimestamp, *v.LastRefreshTimestamp)
	}
	if v.LookBackPeriodInDays != 0 {
		s.WriteFloat64(schemas.InstanceRecommendation_lookBackPeriodInDays, v.LookBackPeriodInDays)
	}
	serializeRecommendationOptions(s, schemas.InstanceRecommendation_recommendationOptions, v.RecommendationOptions)
	serializeRecommendationSources(s, schemas.InstanceRecommendation_recommendationSources, v.RecommendationSources)
	serializeTags(s, schemas.InstanceRecommendation_tags, v.Tags)
	serializeUtilizationMetrics(s, schemas.InstanceRecommendation_utilizationMetrics, v.UtilizationMetrics)
}
func (v *InstanceRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InstanceRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.InstanceRecommendation_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.InstanceRecommendation_accountId, v.AccountId)
		case schemas.InstanceRecommendation_currentInstanceGpuInfo:
			v.CurrentInstanceGpuInfo = &GpuInfo{}
			return v.CurrentInstanceGpuInfo.Deserialize(d)
		case schemas.InstanceRecommendation_currentInstanceType:
			v.CurrentInstanceType = new(string)
			return d.ReadString(schemas.InstanceRecommendation_currentInstanceType, v.CurrentInstanceType)
		case schemas.InstanceRecommendation_currentPerformanceRisk:
			var ev string
			if err := d.ReadString(schemas.InstanceRecommendation_currentPerformanceRisk, &ev); err != nil {
				return err
			}
			v.CurrentPerformanceRisk = CurrentPerformanceRisk(ev)
			return nil
		case schemas.InstanceRecommendation_effectiveRecommendationPreferences:
			v.EffectiveRecommendationPreferences = &EffectiveRecommendationPreferences{}
			return v.EffectiveRecommendationPreferences.Deserialize(d)
		case schemas.InstanceRecommendation_externalMetricStatus:
			v.ExternalMetricStatus = &ExternalMetricStatus{}
			return v.ExternalMetricStatus.Deserialize(d)
		case schemas.InstanceRecommendation_finding:
			var ev string
			if err := d.ReadString(schemas.InstanceRecommendation_finding, &ev); err != nil {
				return err
			}
			v.Finding = Finding(ev)
			return nil
		case schemas.InstanceRecommendation_findingReasonCodes:
			return deserializeInstanceRecommendationFindingReasonCodes(d, schemas.InstanceRecommendation_findingReasonCodes, &v.FindingReasonCodes)
		case schemas.InstanceRecommendation_idle:
			var ev string
			if err := d.ReadString(schemas.InstanceRecommendation_idle, &ev); err != nil {
				return err
			}
			v.Idle = InstanceIdle(ev)
			return nil
		case schemas.InstanceRecommendation_inferredWorkloadTypes:
			return deserializeInferredWorkloadTypes(d, schemas.InstanceRecommendation_inferredWorkloadTypes, &v.InferredWorkloadTypes)
		case schemas.InstanceRecommendation_instanceArn:
			v.InstanceArn = new(string)
			return d.ReadString(schemas.InstanceRecommendation_instanceArn, v.InstanceArn)
		case schemas.InstanceRecommendation_instanceName:
			v.InstanceName = new(string)
			return d.ReadString(schemas.InstanceRecommendation_instanceName, v.InstanceName)
		case schemas.InstanceRecommendation_instanceState:
			var ev string
			if err := d.ReadString(schemas.InstanceRecommendation_instanceState, &ev); err != nil {
				return err
			}
			v.InstanceState = InstanceState(ev)
			return nil
		case schemas.InstanceRecommendation_lastRefreshTimestamp:
			v.LastRefreshTimestamp = new(time.Time)
			return d.ReadTime(schemas.InstanceRecommendation_lastRefreshTimestamp, v.LastRefreshTimestamp)
		case schemas.InstanceRecommendation_lookBackPeriodInDays:
			return d.ReadFloat64(schemas.InstanceRecommendation_lookBackPeriodInDays, &v.LookBackPeriodInDays)
		case schemas.InstanceRecommendation_recommendationOptions:
			return deserializeRecommendationOptions(d, schemas.InstanceRecommendation_recommendationOptions, &v.RecommendationOptions)
		case schemas.InstanceRecommendation_recommendationSources:
			return deserializeRecommendationSources(d, schemas.InstanceRecommendation_recommendationSources, &v.RecommendationSources)
		case schemas.InstanceRecommendation_tags:
			return deserializeTags(d, schemas.InstanceRecommendation_tags, &v.Tags)
		case schemas.InstanceRecommendation_utilizationMetrics:
			return deserializeUtilizationMetrics(d, schemas.InstanceRecommendation_utilizationMetrics, &v.UtilizationMetrics)
		}
		return nil
	})
}

// Describes a recommendation option for an Amazon EC2 instance.
type InstanceRecommendationOption struct {

	//  Describes the GPU accelerator settings for the recommended instance type.
	InstanceGpuInfo *GpuInfo

	// The instance type of the instance recommendation.
	InstanceType *string

	// The level of effort required to migrate from the current instance type to the
	// recommended instance type.
	//
	// For example, the migration effort is Low if Amazon EMR is the inferred workload
	// type and an Amazon Web Services Graviton instance type is recommended. The
	// migration effort is Medium if a workload type couldn't be inferred but an
	// Amazon Web Services Graviton instance type is recommended. The migration effort
	// is VeryLow if both the current and recommended instance types are of the same
	// CPU architecture.
	MigrationEffort MigrationEffort

	// The performance risk of the instance recommendation option.
	//
	// Performance risk indicates the likelihood of the recommended instance type not
	// meeting the resource needs of your workload. Compute Optimizer calculates an
	// individual performance risk score for each specification of the recommended
	// instance, including CPU, memory, EBS throughput, EBS IOPS, disk throughput, disk
	// IOPS, network throughput, and network PPS. The performance risk of the
	// recommended instance is calculated as the maximum performance risk score across
	// the analyzed resource specifications.
	//
	// The value ranges from 0 - 4 , with 0 meaning that the recommended resource is
	// predicted to always provide enough hardware capability. The higher the
	// performance risk is, the more likely you should validate whether the
	// recommendation will meet the performance requirements of your workload before
	// migrating your resource.
	PerformanceRisk float64

	// Describes the configuration differences between the current instance and the
	// recommended instance type. You should consider the configuration differences
	// before migrating your workloads from the current instance to the recommended
	// instance type. The [Change the instance type guide for Linux]and [Change the instance type guide for Windows] provide general guidance for getting started with an
	// instance migration.
	//
	// Platform differences include:
	//
	//   - Hypervisor — The hypervisor of the recommended instance type is different
	//   than that of the current instance. For example, the recommended instance type
	//   uses a Nitro hypervisor and the current instance uses a Xen hypervisor. The
	//   differences that you should consider between these hypervisors are covered in
	//   the [Nitro Hypervisor]section of the Amazon EC2 frequently asked questions. For more
	//   information, see [Instances built on the Nitro System]in the Amazon EC2 User Guide for Linux, or [Instances built on the Nitro System]in the Amazon EC2
	//   User Guide for Windows.
	//
	//   - NetworkInterface — The network interface of the recommended instance type is
	//   different than that of the current instance. For example, the recommended
	//   instance type supports enhanced networking and the current instance might not.
	//   To enable enhanced networking for the recommended instance type, you must
	//   install the Elastic Network Adapter (ENA) driver or the Intel 82599 Virtual
	//   Function driver. For more information, see [Networking and storage features]and [Enhanced networking on Linux]in the Amazon EC2 User Guide
	//   for Linux, or [Networking and storage features]and [Enhanced networking on Windows]in the Amazon EC2 User Guide for Windows.
	//
	//   - StorageInterface — The storage interface of the recommended instance type is
	//   different than that of the current instance. For example, the recommended
	//   instance type uses an NVMe storage interface and the current instance does not.
	//   To access NVMe volumes for the recommended instance type, you will need to
	//   install or upgrade the NVMe driver. For more information, see [Networking and storage features]and [Amazon EBS and NVMe on Linux instances]in the
	//   Amazon EC2 User Guide for Linux, or [Networking and storage features]and [Amazon EBS and NVMe on Windows instances]in the Amazon EC2 User Guide for
	//   Windows.
	//
	//   - InstanceStoreAvailability — The recommended instance type does not support
	//   instance store volumes and the current instance does. Before migrating, you
	//   might need to back up the data on your instance store volumes if you want to
	//   preserve them. For more information, see [How do I back up an instance store volume on my Amazon EC2 instance to Amazon EBS?]in the Amazon Web Services Premium
	//   Support Knowledge Base. For more information, see [Networking and storage features]and [Amazon EC2 instance store]in the Amazon EC2 User
	//   Guide for Linux, or see [Networking and storage features]and [Amazon EC2 instance store]in the Amazon EC2 User Guide for Windows.
	//
	//   - VirtualizationType — The recommended instance type uses the hardware virtual
	//   machine (HVM) virtualization type and the current instance uses the paravirtual
	//   (PV) virtualization type. For more information about the differences between
	//   these virtualization types, see [Linux AMI virtualization types]in the Amazon EC2 User Guide for Linux, or [Windows AMI virtualization types]in
	//   the Amazon EC2 User Guide for Windows.
	//
	//   - Architecture — The CPU architecture between the recommended instance type
	//   and the current instance is different. For example, the recommended instance
	//   type might use an Arm CPU architecture and the current instance type might use a
	//   different one, such as x86. Before migrating, you should consider recompiling
	//   the software on your instance for the new architecture. Alternatively, you might
	//   switch to an Amazon Machine Image (AMI) that supports the new architecture. For
	//   more information about the CPU architecture for each instance type, see [Amazon EC2 Instance Types].
	//
	// [Enhanced networking on Linux]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enhanced-networking.html
	// [Amazon EBS and NVMe on Linux instances]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/nvme-ebs-volumes.html
	// [How do I back up an instance store volume on my Amazon EC2 instance to Amazon EBS?]: https://aws.amazon.com/premiumsupport/knowledge-center/back-up-instance-store-ebs/
	// [Enhanced networking on Windows]: https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/enhanced-networking.html
	// [Instances built on the Nitro System]: https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/instance-types.html#ec2-nitro-instances
	// [Networking and storage features]: https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/instance-types.html#instance-networking-storage
	// [Change the instance type guide for Windows]: https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-instance-resize.html
	// [Linux AMI virtualization types]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/virtualization_types.html
	// [Amazon EC2 instance store]: https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/InstanceStorage.html
	// [Nitro Hypervisor]: http://aws.amazon.com/ec2/faqs/#Nitro_Hypervisor
	// [Amazon EC2 Instance Types]: http://aws.amazon.com/ec2/instance-types/
	// [Amazon EBS and NVMe on Windows instances]: https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/nvme-ebs-volumes.html
	// [Windows AMI virtualization types]: https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/windows-ami-version-history.html#virtualization-types
	// [Change the instance type guide for Linux]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-resize.html
	PlatformDifferences []PlatformDifference

	// An array of objects that describe the projected utilization metrics of the
	// instance recommendation option.
	//
	// The Cpu and Memory metrics are the only projected utilization metrics returned.
	// Additionally, the Memory metric is returned only for resources that have the
	// unified CloudWatch agent installed on them. For more information, see [Enabling Memory Utilization with the CloudWatch Agent].
	//
	// [Enabling Memory Utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#cw-agent
	ProjectedUtilizationMetrics []UtilizationMetric

	// The rank of the instance recommendation option.
	//
	// The top recommendation option is ranked as 1 .
	Rank int32

	// An object that describes the savings opportunity for the instance
	// recommendation option. Savings opportunity includes the estimated monthly
	// savings amount and percentage.
	SavingsOpportunity *SavingsOpportunity

	//  An object that describes the savings opportunity for the instance
	// recommendation option that includes Savings Plans and Reserved Instances
	// discounts. Savings opportunity includes the estimated monthly savings and
	// percentage.
	SavingsOpportunityAfterDiscounts *InstanceSavingsOpportunityAfterDiscounts

	noSmithyDocumentSerde
}

func (v *InstanceRecommendationOption) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.InstanceRecommendationOption)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *InstanceRecommendationOption) SerializeMembers(s smithy.ShapeSerializer) {
	if v.InstanceGpuInfo != nil {
		s.WriteStruct(schemas.InstanceRecommendationOption_instanceGpuInfo)
		v.InstanceGpuInfo.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.InstanceType != nil {
		s.WriteString(schemas.InstanceRecommendationOption_instanceType, *v.InstanceType)
	}
	if v.MigrationEffort != "" {
		s.WriteString(schemas.InstanceRecommendationOption_migrationEffort, string(v.MigrationEffort))
	}
	if v.PerformanceRisk != 0 {
		s.WriteFloat64(schemas.InstanceRecommendationOption_performanceRisk, v.PerformanceRisk)
	}
	serializePlatformDifferences(s, schemas.InstanceRecommendationOption_platformDifferences, v.PlatformDifferences)
	serializeProjectedUtilizationMetrics(s, schemas.InstanceRecommendationOption_projectedUtilizationMetrics, v.ProjectedUtilizationMetrics)
	if v.Rank != 0 {
		s.WriteInt32(schemas.InstanceRecommendationOption_rank, v.Rank)
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.InstanceRecommendationOption_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityAfterDiscounts != nil {
		s.WriteStruct(schemas.InstanceRecommendationOption_savingsOpportunityAfterDiscounts)
		v.SavingsOpportunityAfterDiscounts.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *InstanceRecommendationOption) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InstanceRecommendationOption, func(s *smithy.Schema) error {
		switch s {
		case schemas.InstanceRecommendationOption_instanceGpuInfo:
			v.InstanceGpuInfo = &GpuInfo{}
			return v.InstanceGpuInfo.Deserialize(d)
		case schemas.InstanceRecommendationOption_instanceType:
			v.InstanceType = new(string)
			return d.ReadString(schemas.InstanceRecommendationOption_instanceType, v.InstanceType)
		case schemas.InstanceRecommendationOption_migrationEffort:
			var ev string
			if err := d.ReadString(schemas.InstanceRecommendationOption_migrationEffort, &ev); err != nil {
				return err
			}
			v.MigrationEffort = MigrationEffort(ev)
			return nil
		case schemas.InstanceRecommendationOption_performanceRisk:
			return d.ReadFloat64(schemas.InstanceRecommendationOption_performanceRisk, &v.PerformanceRisk)
		case schemas.InstanceRecommendationOption_platformDifferences:
			return deserializePlatformDifferences(d, schemas.InstanceRecommendationOption_platformDifferences, &v.PlatformDifferences)
		case schemas.InstanceRecommendationOption_projectedUtilizationMetrics:
			return deserializeProjectedUtilizationMetrics(d, schemas.InstanceRecommendationOption_projectedUtilizationMetrics, &v.ProjectedUtilizationMetrics)
		case schemas.InstanceRecommendationOption_rank:
			return d.ReadInt32(schemas.InstanceRecommendationOption_rank, &v.Rank)
		case schemas.InstanceRecommendationOption_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.InstanceRecommendationOption_savingsOpportunityAfterDiscounts:
			v.SavingsOpportunityAfterDiscounts = &InstanceSavingsOpportunityAfterDiscounts{}
			return v.SavingsOpportunityAfterDiscounts.Deserialize(d)
		}
		return nil
	})
}

//	Describes the savings estimation mode used for calculating savings opportunity
//
// for Amazon EC2 instances.
type InstanceSavingsEstimationMode struct {

	//  Describes the source for calculating the savings opportunity for Amazon EC2
	// instances.
	Source InstanceSavingsEstimationModeSource

	noSmithyDocumentSerde
}

func (v *InstanceSavingsEstimationMode) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.InstanceSavingsEstimationMode)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *InstanceSavingsEstimationMode) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Source != "" {
		s.WriteString(schemas.InstanceSavingsEstimationMode_source, string(v.Source))
	}
}
func (v *InstanceSavingsEstimationMode) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InstanceSavingsEstimationMode, func(s *smithy.Schema) error {
		switch s {
		case schemas.InstanceSavingsEstimationMode_source:
			var ev string
			if err := d.ReadString(schemas.InstanceSavingsEstimationMode_source, &ev); err != nil {
				return err
			}
			v.Source = InstanceSavingsEstimationModeSource(ev)
			return nil
		}
		return nil
	})
}

//	Describes the savings opportunity for instance recommendations after applying
//
// the Savings Plans and Reserved Instances discounts.
//
// Savings opportunity after discounts represents the estimated monthly savings
// you can achieve by implementing Compute Optimizer recommendations.
type InstanceSavingsOpportunityAfterDiscounts struct {

	//  An object that describes the estimated monthly savings possible by adopting
	// Compute Optimizer’s Amazon EC2 instance recommendations. This is based on
	// pricing after applying the Savings Plans and Reserved Instances discounts.
	EstimatedMonthlySavings *InstanceEstimatedMonthlySavings

	//  The estimated monthly savings possible as a percentage of monthly cost after
	// applying the Savings Plans and Reserved Instances discounts. This saving can be
	// achieved by adopting Compute Optimizer’s EC2 instance recommendations.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *InstanceSavingsOpportunityAfterDiscounts) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.InstanceSavingsOpportunityAfterDiscounts)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *InstanceSavingsOpportunityAfterDiscounts) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.InstanceSavingsOpportunityAfterDiscounts_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.InstanceSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *InstanceSavingsOpportunityAfterDiscounts) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InstanceSavingsOpportunityAfterDiscounts, func(s *smithy.Schema) error {
		switch s {
		case schemas.InstanceSavingsOpportunityAfterDiscounts_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &InstanceEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.InstanceSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.InstanceSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

// Describes a filter that returns a more specific list of recommendation export
// jobs. Use this filter with the DescribeRecommendationExportJobsaction.
//
// You can use EBSFilter with the GetEBSVolumeRecommendations action, LambdaFunctionRecommendationFilter with
// the GetLambdaFunctionRecommendationsaction, and Filter with the GetAutoScalingGroupRecommendations and GetEC2InstanceRecommendations actions.
type JobFilter struct {

	// The name of the filter.
	//
	// Specify ResourceType to return export jobs of a specific resource type (for
	// example, Ec2Instance ).
	//
	// Specify JobStatus to return export jobs with a specific status (e.g, Complete ).
	Name JobFilterName

	// The value of the filter.
	//
	// The valid values for this parameter are as follows, depending on what you
	// specify for the name parameter:
	//
	//   - Specify Ec2Instance or AutoScalingGroup if you specify the name parameter as
	//   ResourceType . There is no filter for EBS volumes because volume
	//   recommendations cannot be exported at this time.
	//
	//   - Specify Queued , InProgress , Complete , or Failed if you specify the name
	//   parameter as JobStatus .
	Values []string

	noSmithyDocumentSerde
}

func (v *JobFilter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.JobFilter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *JobFilter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.JobFilter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.JobFilter_values, v.Values)
}
func (v *JobFilter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.JobFilter, func(s *smithy.Schema) error {
		switch s {
		case schemas.JobFilter_name:
			var ev string
			if err := d.ReadString(schemas.JobFilter_name, &ev); err != nil {
				return err
			}
			v.Name = JobFilterName(ev)
			return nil
		case schemas.JobFilter_values:
			return deserializeFilterValues(d, schemas.JobFilter_values, &v.Values)
		}
		return nil
	})
}

// Describes the effective recommendation preferences for Lambda functions.
type LambdaEffectiveRecommendationPreferences struct {

	//  Describes the savings estimation mode applied for calculating savings
	// opportunity for Lambda functions.
	SavingsEstimationMode *LambdaSavingsEstimationMode

	noSmithyDocumentSerde
}

func (v *LambdaEffectiveRecommendationPreferences) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaEffectiveRecommendationPreferences)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaEffectiveRecommendationPreferences) SerializeMembers(s smithy.ShapeSerializer) {
	if v.SavingsEstimationMode != nil {
		s.WriteStruct(schemas.LambdaEffectiveRecommendationPreferences_savingsEstimationMode)
		v.SavingsEstimationMode.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *LambdaEffectiveRecommendationPreferences) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaEffectiveRecommendationPreferences, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaEffectiveRecommendationPreferences_savingsEstimationMode:
			v.SavingsEstimationMode = &LambdaSavingsEstimationMode{}
			return v.SavingsEstimationMode.Deserialize(d)
		}
		return nil
	})
}

//	Describes the estimated monthly savings possible for Lambda functions by
//
// adopting Compute Optimizer recommendations. This is based on Lambda functions
// pricing after applying Savings Plans discounts.
type LambdaEstimatedMonthlySavings struct {

	//  The currency of the estimated monthly savings.
	Currency Currency

	//  The value of the estimated monthly savings.
	Value float64

	noSmithyDocumentSerde
}

func (v *LambdaEstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaEstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaEstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.LambdaEstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.LambdaEstimatedMonthlySavings_value, v.Value)
	}
}
func (v *LambdaEstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaEstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaEstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.LambdaEstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.LambdaEstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.LambdaEstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

// Describes a projected utilization metric of an Lambda function recommendation
// option.
type LambdaFunctionMemoryProjectedMetric struct {

	// The name of the projected utilization metric.
	Name LambdaFunctionMemoryMetricName

	// The statistic of the projected utilization metric.
	Statistic LambdaFunctionMemoryMetricStatistic

	// The values of the projected utilization metrics.
	Value float64

	noSmithyDocumentSerde
}

func (v *LambdaFunctionMemoryProjectedMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaFunctionMemoryProjectedMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaFunctionMemoryProjectedMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.LambdaFunctionMemoryProjectedMetric_name, string(v.Name))
	}
	if v.Statistic != "" {
		s.WriteString(schemas.LambdaFunctionMemoryProjectedMetric_statistic, string(v.Statistic))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.LambdaFunctionMemoryProjectedMetric_value, v.Value)
	}
}
func (v *LambdaFunctionMemoryProjectedMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaFunctionMemoryProjectedMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaFunctionMemoryProjectedMetric_name:
			var ev string
			if err := d.ReadString(schemas.LambdaFunctionMemoryProjectedMetric_name, &ev); err != nil {
				return err
			}
			v.Name = LambdaFunctionMemoryMetricName(ev)
			return nil
		case schemas.LambdaFunctionMemoryProjectedMetric_statistic:
			var ev string
			if err := d.ReadString(schemas.LambdaFunctionMemoryProjectedMetric_statistic, &ev); err != nil {
				return err
			}
			v.Statistic = LambdaFunctionMemoryMetricStatistic(ev)
			return nil
		case schemas.LambdaFunctionMemoryProjectedMetric_value:
			return d.ReadFloat64(schemas.LambdaFunctionMemoryProjectedMetric_value, &v.Value)
		}
		return nil
	})
}

// Describes a recommendation option for an Lambda function.
type LambdaFunctionMemoryRecommendationOption struct {

	// The memory size, in MB, of the function recommendation option.
	MemorySize int32

	// An array of objects that describe the projected utilization metrics of the
	// function recommendation option.
	ProjectedUtilizationMetrics []LambdaFunctionMemoryProjectedMetric

	// The rank of the function recommendation option.
	//
	// The top recommendation option is ranked as 1 .
	Rank int32

	// An object that describes the savings opportunity for the Lambda function
	// recommendation option. Savings opportunity includes the estimated monthly
	// savings amount and percentage.
	SavingsOpportunity *SavingsOpportunity

	//  An object that describes the savings opportunity for the Lambda recommendation
	// option which includes Saving Plans discounts. Savings opportunity includes the
	// estimated monthly savings and percentage.
	SavingsOpportunityAfterDiscounts *LambdaSavingsOpportunityAfterDiscounts

	noSmithyDocumentSerde
}

func (v *LambdaFunctionMemoryRecommendationOption) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaFunctionMemoryRecommendationOption)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaFunctionMemoryRecommendationOption) SerializeMembers(s smithy.ShapeSerializer) {
	if v.MemorySize != 0 {
		s.WriteInt32(schemas.LambdaFunctionMemoryRecommendationOption_memorySize, v.MemorySize)
	}
	serializeLambdaFunctionMemoryProjectedMetrics(s, schemas.LambdaFunctionMemoryRecommendationOption_projectedUtilizationMetrics, v.ProjectedUtilizationMetrics)
	if v.Rank != 0 {
		s.WriteInt32(schemas.LambdaFunctionMemoryRecommendationOption_rank, v.Rank)
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.LambdaFunctionMemoryRecommendationOption_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityAfterDiscounts != nil {
		s.WriteStruct(schemas.LambdaFunctionMemoryRecommendationOption_savingsOpportunityAfterDiscounts)
		v.SavingsOpportunityAfterDiscounts.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *LambdaFunctionMemoryRecommendationOption) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaFunctionMemoryRecommendationOption, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaFunctionMemoryRecommendationOption_memorySize:
			return d.ReadInt32(schemas.LambdaFunctionMemoryRecommendationOption_memorySize, &v.MemorySize)
		case schemas.LambdaFunctionMemoryRecommendationOption_projectedUtilizationMetrics:
			return deserializeLambdaFunctionMemoryProjectedMetrics(d, schemas.LambdaFunctionMemoryRecommendationOption_projectedUtilizationMetrics, &v.ProjectedUtilizationMetrics)
		case schemas.LambdaFunctionMemoryRecommendationOption_rank:
			return d.ReadInt32(schemas.LambdaFunctionMemoryRecommendationOption_rank, &v.Rank)
		case schemas.LambdaFunctionMemoryRecommendationOption_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.LambdaFunctionMemoryRecommendationOption_savingsOpportunityAfterDiscounts:
			v.SavingsOpportunityAfterDiscounts = &LambdaSavingsOpportunityAfterDiscounts{}
			return v.SavingsOpportunityAfterDiscounts.Deserialize(d)
		}
		return nil
	})
}

// Describes an Lambda function recommendation.
type LambdaFunctionRecommendation struct {

	// The Amazon Web Services account ID of the function.
	AccountId *string

	// The amount of memory, in MB, that's allocated to the current function.
	CurrentMemorySize int32

	// The risk of the current Lambda function not meeting the performance needs of
	// its workloads. The higher the risk, the more likely the current Lambda function
	// requires more memory.
	CurrentPerformanceRisk CurrentPerformanceRisk

	//  Describes the effective recommendation preferences for Lambda functions.
	EffectiveRecommendationPreferences *LambdaEffectiveRecommendationPreferences

	// The finding classification of the function.
	//
	// Findings for functions include:
	//
	//   - Optimized — The function is correctly provisioned to run your workload based
	//   on its current configuration and its utilization history. This finding
	//   classification does not include finding reason codes.
	//
	//   - NotOptimized — The function is performing at a higher level
	//   (over-provisioned) or at a lower level (under-provisioned) than required for
	//   your workload because its current configuration is not optimal. Over-provisioned
	//   resources might lead to unnecessary infrastructure cost, and under-provisioned
	//   resources might lead to poor application performance. This finding
	//   classification can include the MemoryUnderprovisioned and
	//   MemoryUnderprovisioned finding reason codes.
	//
	//   - Unavailable — Compute Optimizer was unable to generate a recommendation for
	//   the function. This could be because the function has not accumulated sufficient
	//   metric data, or the function does not qualify for a recommendation. This finding
	//   classification can include the InsufficientData and Inconclusive finding
	//   reason codes.
	//
	// Functions with a finding of unavailable are not returned unless you specify the
	//   filter parameter with a value of Unavailable in your
	//   GetLambdaFunctionRecommendations request.
	Finding LambdaFunctionRecommendationFinding

	// The reason for the finding classification of the function.
	//
	// Functions that have a finding classification of Optimized don't have a finding
	// reason code.
	//
	// Finding reason codes for functions include:
	//
	//   - MemoryOverprovisioned — The function is over-provisioned when its memory
	//   configuration can be sized down while still meeting the performance requirements
	//   of your workload. An over-provisioned function might lead to unnecessary
	//   infrastructure cost. This finding reason code is part of the NotOptimized
	//   finding classification.
	//
	//   - MemoryUnderprovisioned — The function is under-provisioned when its memory
	//   configuration doesn't meet the performance requirements of the workload. An
	//   under-provisioned function might lead to poor application performance. This
	//   finding reason code is part of the NotOptimized finding classification.
	//
	//   - InsufficientData — The function does not have sufficient metric data for
	//   Compute Optimizer to generate a recommendation. For more information, see the [Supported resources and requirements]
	//   in the Compute Optimizer User Guide. This finding reason code is part of the
	//   Unavailable finding classification.
	//
	//   - Inconclusive — The function does not qualify for a recommendation because
	//   Compute Optimizer cannot generate a recommendation with a high degree of
	//   confidence. This finding reason code is part of the Unavailable finding
	//   classification.
	//
	// [Supported resources and requirements]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/requirements.html
	FindingReasonCodes []LambdaFunctionRecommendationFindingReasonCode

	// The Amazon Resource Name (ARN) of the current function.
	FunctionArn *string

	// The version number of the current function.
	FunctionVersion *string

	// The timestamp of when the function recommendation was last generated.
	LastRefreshTimestamp *time.Time

	// The number of days for which utilization metrics were analyzed for the function.
	LookbackPeriodInDays float64

	// An array of objects that describe the memory configuration recommendation
	// options for the function.
	MemorySizeRecommendationOptions []LambdaFunctionMemoryRecommendationOption

	// The number of times your function code was applied during the look-back period.
	NumberOfInvocations int64

	//  A list of tags assigned to your Lambda function recommendations.
	Tags []Tag

	// An array of objects that describe the utilization metrics of the function.
	UtilizationMetrics []LambdaFunctionUtilizationMetric

	noSmithyDocumentSerde
}

func (v *LambdaFunctionRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaFunctionRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaFunctionRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.LambdaFunctionRecommendation_accountId, *v.AccountId)
	}
	if v.CurrentMemorySize != 0 {
		s.WriteInt32(schemas.LambdaFunctionRecommendation_currentMemorySize, v.CurrentMemorySize)
	}
	if v.CurrentPerformanceRisk != "" {
		s.WriteString(schemas.LambdaFunctionRecommendation_currentPerformanceRisk, string(v.CurrentPerformanceRisk))
	}
	if v.EffectiveRecommendationPreferences != nil {
		s.WriteStruct(schemas.LambdaFunctionRecommendation_effectiveRecommendationPreferences)
		v.EffectiveRecommendationPreferences.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Finding != "" {
		s.WriteString(schemas.LambdaFunctionRecommendation_finding, string(v.Finding))
	}
	serializeLambdaFunctionRecommendationFindingReasonCodes(s, schemas.LambdaFunctionRecommendation_findingReasonCodes, v.FindingReasonCodes)
	if v.FunctionArn != nil {
		s.WriteString(schemas.LambdaFunctionRecommendation_functionArn, *v.FunctionArn)
	}
	if v.FunctionVersion != nil {
		s.WriteString(schemas.LambdaFunctionRecommendation_functionVersion, *v.FunctionVersion)
	}
	if v.LastRefreshTimestamp != nil {
		s.WriteTime(schemas.LambdaFunctionRecommendation_lastRefreshTimestamp, *v.LastRefreshTimestamp)
	}
	if v.LookbackPeriodInDays != 0 {
		s.WriteFloat64(schemas.LambdaFunctionRecommendation_lookbackPeriodInDays, v.LookbackPeriodInDays)
	}
	serializeLambdaFunctionMemoryRecommendationOptions(s, schemas.LambdaFunctionRecommendation_memorySizeRecommendationOptions, v.MemorySizeRecommendationOptions)
	if v.NumberOfInvocations != 0 {
		s.WriteInt64(schemas.LambdaFunctionRecommendation_numberOfInvocations, v.NumberOfInvocations)
	}
	serializeTags(s, schemas.LambdaFunctionRecommendation_tags, v.Tags)
	serializeLambdaFunctionUtilizationMetrics(s, schemas.LambdaFunctionRecommendation_utilizationMetrics, v.UtilizationMetrics)
}
func (v *LambdaFunctionRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaFunctionRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaFunctionRecommendation_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.LambdaFunctionRecommendation_accountId, v.AccountId)
		case schemas.LambdaFunctionRecommendation_currentMemorySize:
			return d.ReadInt32(schemas.LambdaFunctionRecommendation_currentMemorySize, &v.CurrentMemorySize)
		case schemas.LambdaFunctionRecommendation_currentPerformanceRisk:
			var ev string
			if err := d.ReadString(schemas.LambdaFunctionRecommendation_currentPerformanceRisk, &ev); err != nil {
				return err
			}
			v.CurrentPerformanceRisk = CurrentPerformanceRisk(ev)
			return nil
		case schemas.LambdaFunctionRecommendation_effectiveRecommendationPreferences:
			v.EffectiveRecommendationPreferences = &LambdaEffectiveRecommendationPreferences{}
			return v.EffectiveRecommendationPreferences.Deserialize(d)
		case schemas.LambdaFunctionRecommendation_finding:
			var ev string
			if err := d.ReadString(schemas.LambdaFunctionRecommendation_finding, &ev); err != nil {
				return err
			}
			v.Finding = LambdaFunctionRecommendationFinding(ev)
			return nil
		case schemas.LambdaFunctionRecommendation_findingReasonCodes:
			return deserializeLambdaFunctionRecommendationFindingReasonCodes(d, schemas.LambdaFunctionRecommendation_findingReasonCodes, &v.FindingReasonCodes)
		case schemas.LambdaFunctionRecommendation_functionArn:
			v.FunctionArn = new(string)
			return d.ReadString(schemas.LambdaFunctionRecommendation_functionArn, v.FunctionArn)
		case schemas.LambdaFunctionRecommendation_functionVersion:
			v.FunctionVersion = new(string)
			return d.ReadString(schemas.LambdaFunctionRecommendation_functionVersion, v.FunctionVersion)
		case schemas.LambdaFunctionRecommendation_lastRefreshTimestamp:
			v.LastRefreshTimestamp = new(time.Time)
			return d.ReadTime(schemas.LambdaFunctionRecommendation_lastRefreshTimestamp, v.LastRefreshTimestamp)
		case schemas.LambdaFunctionRecommendation_lookbackPeriodInDays:
			return d.ReadFloat64(schemas.LambdaFunctionRecommendation_lookbackPeriodInDays, &v.LookbackPeriodInDays)
		case schemas.LambdaFunctionRecommendation_memorySizeRecommendationOptions:
			return deserializeLambdaFunctionMemoryRecommendationOptions(d, schemas.LambdaFunctionRecommendation_memorySizeRecommendationOptions, &v.MemorySizeRecommendationOptions)
		case schemas.LambdaFunctionRecommendation_numberOfInvocations:
			return d.ReadInt64(schemas.LambdaFunctionRecommendation_numberOfInvocations, &v.NumberOfInvocations)
		case schemas.LambdaFunctionRecommendation_tags:
			return deserializeTags(d, schemas.LambdaFunctionRecommendation_tags, &v.Tags)
		case schemas.LambdaFunctionRecommendation_utilizationMetrics:
			return deserializeLambdaFunctionUtilizationMetrics(d, schemas.LambdaFunctionRecommendation_utilizationMetrics, &v.UtilizationMetrics)
		}
		return nil
	})
}

// Describes a filter that returns a more specific list of Lambda function
// recommendations. Use this filter with the GetLambdaFunctionRecommendationsaction.
//
// You can use EBSFilter with the GetEBSVolumeRecommendations action, JobFilter with the DescribeRecommendationExportJobs action, and Filter
// with the GetAutoScalingGroupRecommendationsand GetEC2InstanceRecommendations actions.
type LambdaFunctionRecommendationFilter struct {

	// The name of the filter.
	//
	// Specify Finding to return recommendations with a specific finding
	// classification (for example, NotOptimized ).
	//
	// Specify FindingReasonCode to return recommendations with a specific finding
	// reason code (for example, MemoryUnderprovisioned ).
	//
	// You can filter your Lambda function recommendations by tag:key and tag-key tags.
	//
	// A tag:key is a key and value combination of a tag assigned to your Lambda
	// function recommendations. Use the tag key in the filter name and the tag value
	// as the filter value. For example, to find all Lambda function recommendations
	// that have a tag with the key of Owner and the value of TeamA , specify tag:Owner
	// for the filter name and TeamA for the filter value.
	//
	// A tag-key is the key of a tag assigned to your Lambda function recommendations.
	// Use this filter to find all of your Lambda function recommendations that have a
	// tag with a specific key. This doesn’t consider the tag value. For example, you
	// can find your Lambda function recommendations with a tag key value of Owner or
	// without any tag keys assigned.
	Name LambdaFunctionRecommendationFilterName

	// The value of the filter.
	//
	// The valid values for this parameter are as follows, depending on what you
	// specify for the name parameter:
	//
	//   - Specify Optimized , NotOptimized , or Unavailable if you specify the name
	//   parameter as Finding .
	//
	//   - Specify MemoryOverprovisioned , MemoryUnderprovisioned , InsufficientData ,
	//   or Inconclusive if you specify the name parameter as FindingReasonCode .
	Values []string

	noSmithyDocumentSerde
}

func (v *LambdaFunctionRecommendationFilter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaFunctionRecommendationFilter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaFunctionRecommendationFilter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.LambdaFunctionRecommendationFilter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.LambdaFunctionRecommendationFilter_values, v.Values)
}
func (v *LambdaFunctionRecommendationFilter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaFunctionRecommendationFilter, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaFunctionRecommendationFilter_name:
			var ev string
			if err := d.ReadString(schemas.LambdaFunctionRecommendationFilter_name, &ev); err != nil {
				return err
			}
			v.Name = LambdaFunctionRecommendationFilterName(ev)
			return nil
		case schemas.LambdaFunctionRecommendationFilter_values:
			return deserializeFilterValues(d, schemas.LambdaFunctionRecommendationFilter_values, &v.Values)
		}
		return nil
	})
}

// Describes a utilization metric of an Lambda function.
type LambdaFunctionUtilizationMetric struct {

	// The name of the utilization metric.
	//
	// The following utilization metrics are available:
	//
	//   - Duration - The amount of time that your function code spends processing an
	//   event.
	//
	//   - Memory - The amount of memory used per invocation.
	Name LambdaFunctionMetricName

	// The statistic of the utilization metric.
	//
	// The Compute Optimizer API, Command Line Interface (CLI), and SDKs return
	// utilization metrics using only the Maximum statistic, which is the highest
	// value observed during the specified period.
	//
	// The Compute Optimizer console displays graphs for some utilization metrics
	// using the Average statistic, which is the value of Sum / SampleCount during the
	// specified period. For more information, see [Viewing resource recommendations]in the Compute Optimizer User
	// Guide. You can also get averaged utilization metric data for your resources
	// using Amazon CloudWatch. For more information, see the [Amazon CloudWatch User Guide].
	//
	// [Viewing resource recommendations]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/viewing-recommendations.html
	// [Amazon CloudWatch User Guide]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html
	Statistic LambdaFunctionMetricStatistic

	// The value of the utilization metric.
	Value float64

	noSmithyDocumentSerde
}

func (v *LambdaFunctionUtilizationMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaFunctionUtilizationMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaFunctionUtilizationMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.LambdaFunctionUtilizationMetric_name, string(v.Name))
	}
	if v.Statistic != "" {
		s.WriteString(schemas.LambdaFunctionUtilizationMetric_statistic, string(v.Statistic))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.LambdaFunctionUtilizationMetric_value, v.Value)
	}
}
func (v *LambdaFunctionUtilizationMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaFunctionUtilizationMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaFunctionUtilizationMetric_name:
			var ev string
			if err := d.ReadString(schemas.LambdaFunctionUtilizationMetric_name, &ev); err != nil {
				return err
			}
			v.Name = LambdaFunctionMetricName(ev)
			return nil
		case schemas.LambdaFunctionUtilizationMetric_statistic:
			var ev string
			if err := d.ReadString(schemas.LambdaFunctionUtilizationMetric_statistic, &ev); err != nil {
				return err
			}
			v.Statistic = LambdaFunctionMetricStatistic(ev)
			return nil
		case schemas.LambdaFunctionUtilizationMetric_value:
			return d.ReadFloat64(schemas.LambdaFunctionUtilizationMetric_value, &v.Value)
		}
		return nil
	})
}

//	Describes the savings estimation used for calculating savings opportunity for
//
// Lambda functions.
type LambdaSavingsEstimationMode struct {

	//  Describes the source for calculation of savings opportunity for Lambda
	// functions.
	Source LambdaSavingsEstimationModeSource

	noSmithyDocumentSerde
}

func (v *LambdaSavingsEstimationMode) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaSavingsEstimationMode)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaSavingsEstimationMode) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Source != "" {
		s.WriteString(schemas.LambdaSavingsEstimationMode_source, string(v.Source))
	}
}
func (v *LambdaSavingsEstimationMode) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaSavingsEstimationMode, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaSavingsEstimationMode_source:
			var ev string
			if err := d.ReadString(schemas.LambdaSavingsEstimationMode_source, &ev); err != nil {
				return err
			}
			v.Source = LambdaSavingsEstimationModeSource(ev)
			return nil
		}
		return nil
	})
}

//	Describes the savings opportunity for Lambda functions recommendations after
//
// applying Savings Plans discounts.
//
// Savings opportunity represents the estimated monthly savings after applying
// Savings Plans discounts. You can achieve this by implementing a given Compute
// Optimizer recommendation.
type LambdaSavingsOpportunityAfterDiscounts struct {

	//  The estimated monthly savings possible by adopting Compute Optimizer’s Lambda
	// function recommendations. This includes any applicable Savings Plans discounts.
	EstimatedMonthlySavings *LambdaEstimatedMonthlySavings

	//  The estimated monthly savings possible as a percentage of monthly cost by
	// adopting Compute Optimizer’s Lambda function recommendations. This includes any
	// applicable Savings Plans discounts.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *LambdaSavingsOpportunityAfterDiscounts) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LambdaSavingsOpportunityAfterDiscounts)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LambdaSavingsOpportunityAfterDiscounts) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.LambdaSavingsOpportunityAfterDiscounts_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.LambdaSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *LambdaSavingsOpportunityAfterDiscounts) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LambdaSavingsOpportunityAfterDiscounts, func(s *smithy.Schema) error {
		switch s {
		case schemas.LambdaSavingsOpportunityAfterDiscounts_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &LambdaEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.LambdaSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.LambdaSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

// Describes the configuration of a license for an Amazon EC2 instance.
type LicenseConfiguration struct {

	//  The instance type used in the license.
	InstanceType *string

	//  The edition of the license for the application that runs on the instance.
	LicenseEdition LicenseEdition

	//  The license type associated with the instance.
	LicenseModel LicenseModel

	//  The name of the license for the application that runs on the instance.
	LicenseName LicenseName

	//  The version of the license for the application that runs on the instance.
	LicenseVersion *string

	//  The list of metric sources required to generate recommendations for commercial
	// software licenses.
	MetricsSource []MetricSource

	//  The current number of cores associated with the instance.
	NumberOfCores int32

	//  The operating system of the instance.
	OperatingSystem *string

	noSmithyDocumentSerde
}

func (v *LicenseConfiguration) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LicenseConfiguration)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LicenseConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.InstanceType != nil {
		s.WriteString(schemas.LicenseConfiguration_instanceType, *v.InstanceType)
	}
	if v.LicenseEdition != "" {
		s.WriteString(schemas.LicenseConfiguration_licenseEdition, string(v.LicenseEdition))
	}
	if v.LicenseModel != "" {
		s.WriteString(schemas.LicenseConfiguration_licenseModel, string(v.LicenseModel))
	}
	if v.LicenseName != "" {
		s.WriteString(schemas.LicenseConfiguration_licenseName, string(v.LicenseName))
	}
	if v.LicenseVersion != nil {
		s.WriteString(schemas.LicenseConfiguration_licenseVersion, *v.LicenseVersion)
	}
	serializeMetricsSource(s, schemas.LicenseConfiguration_metricsSource, v.MetricsSource)
	if v.NumberOfCores != 0 {
		s.WriteInt32(schemas.LicenseConfiguration_numberOfCores, v.NumberOfCores)
	}
	if v.OperatingSystem != nil {
		s.WriteString(schemas.LicenseConfiguration_operatingSystem, *v.OperatingSystem)
	}
}
func (v *LicenseConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LicenseConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.LicenseConfiguration_instanceType:
			v.InstanceType = new(string)
			return d.ReadString(schemas.LicenseConfiguration_instanceType, v.InstanceType)
		case schemas.LicenseConfiguration_licenseEdition:
			var ev string
			if err := d.ReadString(schemas.LicenseConfiguration_licenseEdition, &ev); err != nil {
				return err
			}
			v.LicenseEdition = LicenseEdition(ev)
			return nil
		case schemas.LicenseConfiguration_licenseModel:
			var ev string
			if err := d.ReadString(schemas.LicenseConfiguration_licenseModel, &ev); err != nil {
				return err
			}
			v.LicenseModel = LicenseModel(ev)
			return nil
		case schemas.LicenseConfiguration_licenseName:
			var ev string
			if err := d.ReadString(schemas.LicenseConfiguration_licenseName, &ev); err != nil {
				return err
			}
			v.LicenseName = LicenseName(ev)
			return nil
		case schemas.LicenseConfiguration_licenseVersion:
			v.LicenseVersion = new(string)
			return d.ReadString(schemas.LicenseConfiguration_licenseVersion, v.LicenseVersion)
		case schemas.LicenseConfiguration_metricsSource:
			return deserializeMetricsSource(d, schemas.LicenseConfiguration_metricsSource, &v.MetricsSource)
		case schemas.LicenseConfiguration_numberOfCores:
			return d.ReadInt32(schemas.LicenseConfiguration_numberOfCores, &v.NumberOfCores)
		case schemas.LicenseConfiguration_operatingSystem:
			v.OperatingSystem = new(string)
			return d.ReadString(schemas.LicenseConfiguration_operatingSystem, v.OperatingSystem)
		}
		return nil
	})
}

// Describes a license recommendation for an EC2 instance.
type LicenseRecommendation struct {

	//  The Amazon Web Services account ID of the license.
	AccountId *string

	//  An object that describes the current configuration of an instance that runs on
	// a license.
	CurrentLicenseConfiguration *LicenseConfiguration

	//  The finding classification for an instance that runs on a license.
	//
	// Findings include:
	//
	//   - InsufficentMetrics — When Compute Optimizer detects that your CloudWatch
	//   Application Insights isn't enabled or is enabled with insufficient permissions.
	//
	//   - NotOptimized — When Compute Optimizer detects that your EC2 infrastructure
	//   isn't using any of the SQL server license features you're paying for, a license
	//   is considered not optimized.
	//
	//   - Optimized — When Compute Optimizer detects that all specifications of your
	//   license meet the performance requirements of your workload.
	Finding LicenseFinding

	//  The reason for the finding classification for an instance that runs on a
	// license.
	//
	// Finding reason codes include:
	//
	//   - Optimized — All specifications of your license meet the performance
	//   requirements of your workload.
	//
	//   - LicenseOverprovisioned — A license is considered over-provisioned when your
	//   license can be downgraded while still meeting the performance requirements of
	//   your workload.
	//
	//   - InvalidCloudwatchApplicationInsights — CloudWatch Application Insights isn't
	//   configured properly.
	//
	//   - CloudwatchApplicationInsightsError — There is a CloudWatch Application
	//   Insights error.
	FindingReasonCodes []LicenseFindingReasonCode

	//  The timestamp of when the license recommendation was last generated.
	LastRefreshTimestamp *time.Time

	//  An array of objects that describe the license recommendation options.
	LicenseRecommendationOptions []LicenseRecommendationOption

	//  The number of days for which utilization metrics were analyzed for an instance
	// that runs on a license.
	LookbackPeriodInDays float64

	//  The ARN that identifies the Amazon EC2 instance.
	ResourceArn *string

	//  A list of tags assigned to an EC2 instance.
	Tags []Tag

	noSmithyDocumentSerde
}

func (v *LicenseRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LicenseRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LicenseRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.LicenseRecommendation_accountId, *v.AccountId)
	}
	if v.CurrentLicenseConfiguration != nil {
		s.WriteStruct(schemas.LicenseRecommendation_currentLicenseConfiguration)
		v.CurrentLicenseConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Finding != "" {
		s.WriteString(schemas.LicenseRecommendation_finding, string(v.Finding))
	}
	serializeLicenseFindingReasonCodes(s, schemas.LicenseRecommendation_findingReasonCodes, v.FindingReasonCodes)
	if v.LastRefreshTimestamp != nil {
		s.WriteTime(schemas.LicenseRecommendation_lastRefreshTimestamp, *v.LastRefreshTimestamp)
	}
	serializeLicenseRecommendationOptions(s, schemas.LicenseRecommendation_licenseRecommendationOptions, v.LicenseRecommendationOptions)
	if v.LookbackPeriodInDays != 0 {
		s.WriteFloat64(schemas.LicenseRecommendation_lookbackPeriodInDays, v.LookbackPeriodInDays)
	}
	if v.ResourceArn != nil {
		s.WriteString(schemas.LicenseRecommendation_resourceArn, *v.ResourceArn)
	}
	serializeTags(s, schemas.LicenseRecommendation_tags, v.Tags)
}
func (v *LicenseRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LicenseRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.LicenseRecommendation_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.LicenseRecommendation_accountId, v.AccountId)
		case schemas.LicenseRecommendation_currentLicenseConfiguration:
			v.CurrentLicenseConfiguration = &LicenseConfiguration{}
			return v.CurrentLicenseConfiguration.Deserialize(d)
		case schemas.LicenseRecommendation_finding:
			var ev string
			if err := d.ReadString(schemas.LicenseRecommendation_finding, &ev); err != nil {
				return err
			}
			v.Finding = LicenseFinding(ev)
			return nil
		case schemas.LicenseRecommendation_findingReasonCodes:
			return deserializeLicenseFindingReasonCodes(d, schemas.LicenseRecommendation_findingReasonCodes, &v.FindingReasonCodes)
		case schemas.LicenseRecommendation_lastRefreshTimestamp:
			v.LastRefreshTimestamp = new(time.Time)
			return d.ReadTime(schemas.LicenseRecommendation_lastRefreshTimestamp, v.LastRefreshTimestamp)
		case schemas.LicenseRecommendation_licenseRecommendationOptions:
			return deserializeLicenseRecommendationOptions(d, schemas.LicenseRecommendation_licenseRecommendationOptions, &v.LicenseRecommendationOptions)
		case schemas.LicenseRecommendation_lookbackPeriodInDays:
			return d.ReadFloat64(schemas.LicenseRecommendation_lookbackPeriodInDays, &v.LookbackPeriodInDays)
		case schemas.LicenseRecommendation_resourceArn:
			v.ResourceArn = new(string)
			return d.ReadString(schemas.LicenseRecommendation_resourceArn, v.ResourceArn)
		case schemas.LicenseRecommendation_tags:
			return deserializeTags(d, schemas.LicenseRecommendation_tags, &v.Tags)
		}
		return nil
	})
}

//	Describes a filter that returns a more specific list of license
//
// recommendations. Use this filter with the GetLicenseRecommendation action.
type LicenseRecommendationFilter struct {

	// The name of the filter.
	//
	// Specify Finding to return recommendations with a specific finding
	// classification.
	//
	// Specify FindingReasonCode to return recommendations with a specific finding
	// reason code.
	//
	// You can filter your license recommendations by tag:key and tag-key tags.
	//
	// A tag:key is a key and value combination of a tag assigned to your license
	// recommendations. Use the tag key in the filter name and the tag value as the
	// filter value. For example, to find all license recommendations that have a tag
	// with the key of Owner and the value of TeamA , specify tag:Owner for the filter
	// name and TeamA for the filter value.
	//
	// A tag-key is the key of a tag assigned to your license recommendations. Use
	// this filter to find all of your license recommendations that have a tag with a
	// specific key. This doesn’t consider the tag value. For example, you can find
	// your license recommendations with a tag key value of Owner or without any tag
	// keys assigned.
	Name LicenseRecommendationFilterName

	// The value of the filter.
	//
	// The valid values for this parameter are as follows, depending on what you
	// specify for the name parameter:
	//
	//   - If you specify the name parameter as Finding , then specify Optimized ,
	//   NotOptimized , or InsufficentMetrics .
	//
	//   - If you specify the name parameter as FindingReasonCode , then specify
	//   Optimized , LicenseOverprovisioned , InvalidCloudwatchApplicationInsights , or
	//   CloudwatchApplicationInsightsError .
	Values []string

	noSmithyDocumentSerde
}

func (v *LicenseRecommendationFilter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LicenseRecommendationFilter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LicenseRecommendationFilter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.LicenseRecommendationFilter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.LicenseRecommendationFilter_values, v.Values)
}
func (v *LicenseRecommendationFilter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LicenseRecommendationFilter, func(s *smithy.Schema) error {
		switch s {
		case schemas.LicenseRecommendationFilter_name:
			var ev string
			if err := d.ReadString(schemas.LicenseRecommendationFilter_name, &ev); err != nil {
				return err
			}
			v.Name = LicenseRecommendationFilterName(ev)
			return nil
		case schemas.LicenseRecommendationFilter_values:
			return deserializeFilterValues(d, schemas.LicenseRecommendationFilter_values, &v.Values)
		}
		return nil
	})
}

// Describes the recommendation options for licenses.
type LicenseRecommendationOption struct {

	//  The recommended edition of the license for the application that runs on the
	// instance.
	LicenseEdition LicenseEdition

	//  The recommended license type associated with the instance.
	LicenseModel LicenseModel

	//  The operating system of a license recommendation option.
	OperatingSystem *string

	//  The rank of the license recommendation option.
	//
	// The top recommendation option is ranked as 1 .
	Rank int32

	// Describes the savings opportunity for recommendations of a given resource type
	// or for the recommendation option of an individual resource.
	//
	// Savings opportunity represents the estimated monthly savings you can achieve by
	// implementing a given Compute Optimizer recommendation.
	//
	// Savings opportunity data requires that you opt in to Cost Explorer, as well as
	// activate Receive Amazon EC2 resource recommendations in the Cost Explorer
	// preferences page. That creates a connection between Cost Explorer and Compute
	// Optimizer. With this connection, Cost Explorer generates savings estimates
	// considering the price of existing resources, the price of recommended resources,
	// and historical usage data. Estimated monthly savings reflects the projected
	// dollar savings associated with each of the recommendations generated. For more
	// information, see [Enabling Cost Explorer]and [Optimizing your cost with Rightsizing Recommendations] in the Cost Management User Guide.
	//
	// [Optimizing your cost with Rightsizing Recommendations]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-rightsizing.html
	// [Enabling Cost Explorer]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-enable.html
	SavingsOpportunity *SavingsOpportunity

	noSmithyDocumentSerde
}

func (v *LicenseRecommendationOption) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.LicenseRecommendationOption)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *LicenseRecommendationOption) SerializeMembers(s smithy.ShapeSerializer) {
	if v.LicenseEdition != "" {
		s.WriteString(schemas.LicenseRecommendationOption_licenseEdition, string(v.LicenseEdition))
	}
	if v.LicenseModel != "" {
		s.WriteString(schemas.LicenseRecommendationOption_licenseModel, string(v.LicenseModel))
	}
	if v.OperatingSystem != nil {
		s.WriteString(schemas.LicenseRecommendationOption_operatingSystem, *v.OperatingSystem)
	}
	if v.Rank != 0 {
		s.WriteInt32(schemas.LicenseRecommendationOption_rank, v.Rank)
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.LicenseRecommendationOption_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *LicenseRecommendationOption) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LicenseRecommendationOption, func(s *smithy.Schema) error {
		switch s {
		case schemas.LicenseRecommendationOption_licenseEdition:
			var ev string
			if err := d.ReadString(schemas.LicenseRecommendationOption_licenseEdition, &ev); err != nil {
				return err
			}
			v.LicenseEdition = LicenseEdition(ev)
			return nil
		case schemas.LicenseRecommendationOption_licenseModel:
			var ev string
			if err := d.ReadString(schemas.LicenseRecommendationOption_licenseModel, &ev); err != nil {
				return err
			}
			v.LicenseModel = LicenseModel(ev)
			return nil
		case schemas.LicenseRecommendationOption_operatingSystem:
			v.OperatingSystem = new(string)
			return d.ReadString(schemas.LicenseRecommendationOption_operatingSystem, v.OperatingSystem)
		case schemas.LicenseRecommendationOption_rank:
			return d.ReadInt32(schemas.LicenseRecommendationOption_rank, &v.Rank)
		case schemas.LicenseRecommendationOption_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		}
		return nil
	})
}

// The memory size configurations of a container.
type MemorySizeConfiguration struct {

	//  The amount of memory in the container.
	Memory *int32

	//  The limit of memory reserve for the container.
	MemoryReservation *int32

	noSmithyDocumentSerde
}

func (v *MemorySizeConfiguration) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.MemorySizeConfiguration)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *MemorySizeConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Memory != nil {
		s.WriteInt32(schemas.MemorySizeConfiguration_memory, *v.Memory)
	}
	if v.MemoryReservation != nil {
		s.WriteInt32(schemas.MemorySizeConfiguration_memoryReservation, *v.MemoryReservation)
	}
}
func (v *MemorySizeConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.MemorySizeConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.MemorySizeConfiguration_memory:
			v.Memory = new(int32)
			return d.ReadInt32(schemas.MemorySizeConfiguration_memory, v.Memory)
		case schemas.MemorySizeConfiguration_memoryReservation:
			v.MemoryReservation = new(int32)
			return d.ReadInt32(schemas.MemorySizeConfiguration_memoryReservation, v.MemoryReservation)
		}
		return nil
	})
}

//	The list of metric sources required to generate recommendations for commercial
//
// software licenses.
type MetricSource struct {

	//  The name of the metric source provider.
	Provider MetricSourceProvider

	//  The ARN of the metric source provider.
	ProviderArn *string

	noSmithyDocumentSerde
}

func (v *MetricSource) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.MetricSource)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *MetricSource) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Provider != "" {
		s.WriteString(schemas.MetricSource_provider, string(v.Provider))
	}
	if v.ProviderArn != nil {
		s.WriteString(schemas.MetricSource_providerArn, *v.ProviderArn)
	}
}
func (v *MetricSource) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.MetricSource, func(s *smithy.Schema) error {
		switch s {
		case schemas.MetricSource_provider:
			var ev string
			if err := d.ReadString(schemas.MetricSource_provider, &ev); err != nil {
				return err
			}
			v.Provider = MetricSourceProvider(ev)
			return nil
		case schemas.MetricSource_providerArn:
			v.ProviderArn = new(string)
			return d.ReadString(schemas.MetricSource_providerArn, v.ProviderArn)
		}
		return nil
	})
}

// Describes how the recommendations are ordered.
type OrderBy struct {

	// The dimension values to sort the recommendations.
	Dimension Dimension

	// The order to sort the recommendations.
	Order Order

	noSmithyDocumentSerde
}

func (v *OrderBy) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.OrderBy)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *OrderBy) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Dimension != "" {
		s.WriteString(schemas.OrderBy_dimension, string(v.Dimension))
	}
	if v.Order != "" {
		s.WriteString(schemas.OrderBy_order, string(v.Order))
	}
}
func (v *OrderBy) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.OrderBy, func(s *smithy.Schema) error {
		switch s {
		case schemas.OrderBy_dimension:
			var ev string
			if err := d.ReadString(schemas.OrderBy_dimension, &ev); err != nil {
				return err
			}
			v.Dimension = Dimension(ev)
			return nil
		case schemas.OrderBy_order:
			var ev string
			if err := d.ReadString(schemas.OrderBy_order, &ev); err != nil {
				return err
			}
			v.Order = Order(ev)
			return nil
		}
		return nil
	})
}

//	The preference to control which resource type values are considered when
//
// generating rightsizing recommendations. You can specify this preference as a
// combination of include and exclude lists. You must specify either an includeList
// or excludeList . If the preference is an empty set of resource type values, an
// error occurs. For more information, see [Rightsizing recommendation preferences]in the Compute Optimizer User Guide.
//
//   - This preference is only available for the Amazon EC2 instance and Auto
//     Scaling group resource types.
//
//   - Compute Optimizer only supports the customization of Ec2InstanceTypes .
//
// [Rightsizing recommendation preferences]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/rightsizing-preferences.html
type PreferredResource struct {

	//  The preferred resource type values to exclude from the recommendation
	// candidates. If this isn’t specified, all supported resources are included by
	// default. You can specify up to 1000 values in this list.
	ExcludeList []string

	//  The preferred resource type values to include in the recommendation
	// candidates. You can specify the exact resource type value, such as m5.large, or
	// use wild card expressions, such as m5. If this isn’t specified, all supported
	// resources are included by default. You can specify up to 1000 values in this
	// list.
	IncludeList []string

	//  The type of preferred resource to customize.
	//
	// Compute Optimizer only supports the customization of Ec2InstanceTypes .
	Name PreferredResourceName

	noSmithyDocumentSerde
}

func (v *PreferredResource) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.PreferredResource)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *PreferredResource) SerializeMembers(s smithy.ShapeSerializer) {
	serializePreferredResourceValues(s, schemas.PreferredResource_excludeList, v.ExcludeList)
	serializePreferredResourceValues(s, schemas.PreferredResource_includeList, v.IncludeList)
	if v.Name != "" {
		s.WriteString(schemas.PreferredResource_name, string(v.Name))
	}
}
func (v *PreferredResource) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.PreferredResource, func(s *smithy.Schema) error {
		switch s {
		case schemas.PreferredResource_excludeList:
			return deserializePreferredResourceValues(d, schemas.PreferredResource_excludeList, &v.ExcludeList)
		case schemas.PreferredResource_includeList:
			return deserializePreferredResourceValues(d, schemas.PreferredResource_includeList, &v.IncludeList)
		case schemas.PreferredResource_name:
			var ev string
			if err := d.ReadString(schemas.PreferredResource_name, &ev); err != nil {
				return err
			}
			v.Name = PreferredResourceName(ev)
			return nil
		}
		return nil
	})
}

// Describes a projected utilization metric of a recommendation option, such as an
// Amazon EC2 instance. This represents the projected utilization of a
// recommendation option had you used that resource during the analyzed period.
//
// Compare the utilization metric data of your resource against its projected
// utilization metric data to determine the performance difference between your
// current resource and the recommended option.
//
// The Cpu , Memory , GPU , and GPU_MEMORY metrics are the only projected
// utilization metrics returned when you run the GetEC2RecommendationProjectedMetricsaction. Additionally, these
// metrics are only returned for resources with the unified CloudWatch agent
// installed on them. For more information, see [Enabling Memory Utilization with the CloudWatch Agent]and [Enabling NVIDIA GPU utilization with the CloudWatch Agent].
//
// [Enabling Memory Utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#cw-agent
// [Enabling NVIDIA GPU utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#nvidia-cw-agent
type ProjectedMetric struct {

	// The name of the projected utilization metric.
	//
	// The following projected utilization metrics are returned:
	//
	//   - Cpu - The projected percentage of allocated EC2 compute units that would be
	//   in use on the recommendation option had you used that resource during the
	//   analyzed period. This metric identifies the processing power required to run an
	//   application on the recommendation option.
	//
	// Depending on the instance type, tools in your operating system can show a lower
	//   percentage than CloudWatch when the instance is not allocated a full processor
	//   core.
	//
	//   - Memory - The percentage of memory that would be in use on the recommendation
	//   option had you used that resource during the analyzed period. This metric
	//   identifies the amount of memory required to run an application on the
	//   recommendation option.
	//
	// Units: Percent
	//
	// The Memory metric is only returned for resources with the unified CloudWatch
	//   agent installed on them. For more information, see [Enabling Memory Utilization with the CloudWatch Agent].
	//
	//   - GPU - The projected percentage of allocated GPUs if you adjust your
	//   configurations to Compute Optimizer's recommendation option.
	//
	//   - GPU_MEMORY - The projected percentage of total GPU memory if you adjust your
	//   configurations to Compute Optimizer's recommendation option.
	//
	// The GPU and GPU_MEMORY metrics are only returned for resources with the unified
	//   CloudWatch Agent installed on them. For more information, see [Enabling NVIDIA GPU utilization with the CloudWatch Agent].
	//
	// [Enabling Memory Utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#cw-agent
	// [Enabling NVIDIA GPU utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#nvidia-cw-agent
	Name MetricName

	// The timestamps of the projected utilization metric.
	Timestamps []time.Time

	// The values of the projected utilization metrics.
	Values []float64

	noSmithyDocumentSerde
}

func (v *ProjectedMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ProjectedMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ProjectedMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.ProjectedMetric_name, string(v.Name))
	}
	serializeTimestamps(s, schemas.ProjectedMetric_timestamps, v.Timestamps)
	serializeMetricValues(s, schemas.ProjectedMetric_values, v.Values)
}
func (v *ProjectedMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ProjectedMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.ProjectedMetric_name:
			var ev string
			if err := d.ReadString(schemas.ProjectedMetric_name, &ev); err != nil {
				return err
			}
			v.Name = MetricName(ev)
			return nil
		case schemas.ProjectedMetric_timestamps:
			return deserializeTimestamps(d, schemas.ProjectedMetric_timestamps, &v.Timestamps)
		case schemas.ProjectedMetric_values:
			return deserializeMetricValues(d, schemas.ProjectedMetric_values, &v.Values)
		}
		return nil
	})
}

//	Describes the projected metrics of an Amazon Aurora and RDS database
//
// recommendation option.
//
// To determine the performance difference between your current Amazon Aurora and
// RDS database and the recommended option, compare the metric data of your service
// against its projected metric data.
type RDSDatabaseProjectedMetric struct {

	//  The name of the projected metric.
	Name RDSDBMetricName

	//  The timestamps of the projected metric.
	Timestamps []time.Time

	//  The values for the projected metric.
	Values []float64

	noSmithyDocumentSerde
}

func (v *RDSDatabaseProjectedMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSDatabaseProjectedMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSDatabaseProjectedMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.RDSDatabaseProjectedMetric_name, string(v.Name))
	}
	serializeTimestamps(s, schemas.RDSDatabaseProjectedMetric_timestamps, v.Timestamps)
	serializeMetricValues(s, schemas.RDSDatabaseProjectedMetric_values, v.Values)
}
func (v *RDSDatabaseProjectedMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSDatabaseProjectedMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSDatabaseProjectedMetric_name:
			var ev string
			if err := d.ReadString(schemas.RDSDatabaseProjectedMetric_name, &ev); err != nil {
				return err
			}
			v.Name = RDSDBMetricName(ev)
			return nil
		case schemas.RDSDatabaseProjectedMetric_timestamps:
			return deserializeTimestamps(d, schemas.RDSDatabaseProjectedMetric_timestamps, &v.Timestamps)
		case schemas.RDSDatabaseProjectedMetric_values:
			return deserializeMetricValues(d, schemas.RDSDatabaseProjectedMetric_values, &v.Values)
		}
		return nil
	})
}

//	Describes the projected metrics of an Amazon Aurora and RDS database
//
// recommendation option.
//
// To determine the performance difference between your current Amazon Aurora and
// RDS database and the recommended option, compare the metric data of your service
// against its projected metric data.
type RDSDatabaseRecommendedOptionProjectedMetric struct {

	//  An array of objects that describe the projected metric.
	ProjectedMetrics []RDSDatabaseProjectedMetric

	//  The rank identifier of the Amazon Aurora or RDS DB instance recommendation
	// option.
	Rank int32

	//  The recommended DB instance class for the Amazon Aurora or RDS database.
	RecommendedDBInstanceClass *string

	noSmithyDocumentSerde
}

func (v *RDSDatabaseRecommendedOptionProjectedMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSDatabaseRecommendedOptionProjectedMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSDatabaseRecommendedOptionProjectedMetric) SerializeMembers(s smithy.ShapeSerializer) {
	serializeRDSDatabaseProjectedMetrics(s, schemas.RDSDatabaseRecommendedOptionProjectedMetric_projectedMetrics, v.ProjectedMetrics)
	if v.Rank != 0 {
		s.WriteInt32(schemas.RDSDatabaseRecommendedOptionProjectedMetric_rank, v.Rank)
	}
	if v.RecommendedDBInstanceClass != nil {
		s.WriteString(schemas.RDSDatabaseRecommendedOptionProjectedMetric_recommendedDBInstanceClass, *v.RecommendedDBInstanceClass)
	}
}
func (v *RDSDatabaseRecommendedOptionProjectedMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSDatabaseRecommendedOptionProjectedMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSDatabaseRecommendedOptionProjectedMetric_projectedMetrics:
			return deserializeRDSDatabaseProjectedMetrics(d, schemas.RDSDatabaseRecommendedOptionProjectedMetric_projectedMetrics, &v.ProjectedMetrics)
		case schemas.RDSDatabaseRecommendedOptionProjectedMetric_rank:
			return d.ReadInt32(schemas.RDSDatabaseRecommendedOptionProjectedMetric_rank, &v.Rank)
		case schemas.RDSDatabaseRecommendedOptionProjectedMetric_recommendedDBInstanceClass:
			v.RecommendedDBInstanceClass = new(string)
			return d.ReadString(schemas.RDSDatabaseRecommendedOptionProjectedMetric_recommendedDBInstanceClass, v.RecommendedDBInstanceClass)
		}
		return nil
	})
}

// Describes the recommendation options for a DB instance.
type RDSDBInstanceRecommendationOption struct {

	//  Describes the DB instance class recommendation option for your Amazon Aurora
	// or RDS database.
	DbInstanceClass *string

	//  The performance risk of the DB instance recommendation option.
	PerformanceRisk float64

	//  An array of objects that describe the projected utilization metrics of the DB
	// instance recommendation option.
	ProjectedUtilizationMetrics []RDSDBUtilizationMetric

	//  The rank identifier of the DB instance recommendation option.
	Rank int32

	// Describes the savings opportunity for recommendations of a given resource type
	// or for the recommendation option of an individual resource.
	//
	// Savings opportunity represents the estimated monthly savings you can achieve by
	// implementing a given Compute Optimizer recommendation.
	//
	// Savings opportunity data requires that you opt in to Cost Explorer, as well as
	// activate Receive Amazon EC2 resource recommendations in the Cost Explorer
	// preferences page. That creates a connection between Cost Explorer and Compute
	// Optimizer. With this connection, Cost Explorer generates savings estimates
	// considering the price of existing resources, the price of recommended resources,
	// and historical usage data. Estimated monthly savings reflects the projected
	// dollar savings associated with each of the recommendations generated. For more
	// information, see [Enabling Cost Explorer]and [Optimizing your cost with Rightsizing Recommendations] in the Cost Management User Guide.
	//
	// [Optimizing your cost with Rightsizing Recommendations]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-rightsizing.html
	// [Enabling Cost Explorer]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-enable.html
	SavingsOpportunity *SavingsOpportunity

	//  Describes the savings opportunity for Amazon Aurora and RDS database
	// recommendations or for the recommendation option.
	//
	// Savings opportunity represents the estimated monthly savings after applying
	// Savings Plans discounts. You can achieve this by implementing a given Compute
	// Optimizer recommendation.
	SavingsOpportunityAfterDiscounts *RDSInstanceSavingsOpportunityAfterDiscounts

	noSmithyDocumentSerde
}

func (v *RDSDBInstanceRecommendationOption) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSDBInstanceRecommendationOption)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSDBInstanceRecommendationOption) SerializeMembers(s smithy.ShapeSerializer) {
	if v.DbInstanceClass != nil {
		s.WriteString(schemas.RDSDBInstanceRecommendationOption_dbInstanceClass, *v.DbInstanceClass)
	}
	if v.PerformanceRisk != 0 {
		s.WriteFloat64(schemas.RDSDBInstanceRecommendationOption_performanceRisk, v.PerformanceRisk)
	}
	serializeRDSDBProjectedUtilizationMetrics(s, schemas.RDSDBInstanceRecommendationOption_projectedUtilizationMetrics, v.ProjectedUtilizationMetrics)
	if v.Rank != 0 {
		s.WriteInt32(schemas.RDSDBInstanceRecommendationOption_rank, v.Rank)
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.RDSDBInstanceRecommendationOption_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityAfterDiscounts != nil {
		s.WriteStruct(schemas.RDSDBInstanceRecommendationOption_savingsOpportunityAfterDiscounts)
		v.SavingsOpportunityAfterDiscounts.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *RDSDBInstanceRecommendationOption) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSDBInstanceRecommendationOption, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSDBInstanceRecommendationOption_dbInstanceClass:
			v.DbInstanceClass = new(string)
			return d.ReadString(schemas.RDSDBInstanceRecommendationOption_dbInstanceClass, v.DbInstanceClass)
		case schemas.RDSDBInstanceRecommendationOption_performanceRisk:
			return d.ReadFloat64(schemas.RDSDBInstanceRecommendationOption_performanceRisk, &v.PerformanceRisk)
		case schemas.RDSDBInstanceRecommendationOption_projectedUtilizationMetrics:
			return deserializeRDSDBProjectedUtilizationMetrics(d, schemas.RDSDBInstanceRecommendationOption_projectedUtilizationMetrics, &v.ProjectedUtilizationMetrics)
		case schemas.RDSDBInstanceRecommendationOption_rank:
			return d.ReadInt32(schemas.RDSDBInstanceRecommendationOption_rank, &v.Rank)
		case schemas.RDSDBInstanceRecommendationOption_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.RDSDBInstanceRecommendationOption_savingsOpportunityAfterDiscounts:
			v.SavingsOpportunityAfterDiscounts = &RDSInstanceSavingsOpportunityAfterDiscounts{}
			return v.SavingsOpportunityAfterDiscounts.Deserialize(d)
		}
		return nil
	})
}

// Describes an Amazon Aurora and RDS database recommendation.
type RDSDBRecommendation struct {

	//  The Amazon Web Services account ID of the Amazon Aurora or RDS database.
	AccountId *string

	//  The DB instance class of the current Aurora or RDS DB instance.
	CurrentDBInstanceClass *string

	// The performance risk for the current DB instance.
	CurrentInstancePerformanceRisk RDSCurrentInstancePerformanceRisk

	//  The configuration of the current DB storage.
	CurrentStorageConfiguration *DBStorageConfiguration

	//  The level of variation in monthly I/O costs for the current DB storage
	// configuration.
	CurrentStorageEstimatedMonthlyVolumeIOPsCostVariation RDSEstimatedMonthlyVolumeIOPsCostVariation

	// The identifier for DB cluster.
	DbClusterIdentifier *string

	//  Describes the effective recommendation preferences for DB instances.
	EffectiveRecommendationPreferences *RDSEffectiveRecommendationPreferences

	//  The engine of the DB instance.
	Engine *string

	//  The database engine version.
	EngineVersion *string

	//  This indicates if the DB instance is idle or not.
	Idle Idle

	//  The finding classification of an Amazon Aurora and RDS DB instance.
	//
	// For more information about finding classifications, see [Finding classifications for Aurora and RDS databases] in the Compute
	// Optimizer User Guide.
	//
	// [Finding classifications for Aurora and RDS databases]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/view-rds-recommendations.html#rds-recommendations-findings
	InstanceFinding RDSInstanceFinding

	//  The reason for the finding classification of a DB instance.
	InstanceFindingReasonCodes []RDSInstanceFindingReasonCode

	//  An array of objects that describe the recommendation options for the RDS DB
	// instance.
	InstanceRecommendationOptions []RDSDBInstanceRecommendationOption

	//  The timestamp of when the DB instance recommendation was last generated.
	LastRefreshTimestamp *time.Time

	//  The number of days the DB instance utilization metrics were analyzed.
	LookbackPeriodInDays float64

	// The promotion tier for the Aurora instance.
	PromotionTier *int32

	//  The ARN of the current Amazon Aurora or RDS database.
	//
	// The following is the format of the ARN:
	//
	//     arn:aws:rds:{region}:{accountId}:db:{resourceName}
	ResourceArn *string

	//  The finding classification of Amazon RDS DB instance storage.
	//
	// For more information about finding classifications, see [Finding classifications for Aurora and RDS databases] in the Compute
	// Optimizer User Guide.
	//
	// [Finding classifications for Aurora and RDS databases]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/view-rds-recommendations.html#rds-recommendations-findings
	StorageFinding RDSStorageFinding

	//  The reason for the finding classification of RDS DB instance storage.
	StorageFindingReasonCodes []RDSStorageFindingReasonCode

	//  An array of objects that describe the recommendation options for DB instance
	// storage.
	StorageRecommendationOptions []RDSDBStorageRecommendationOption

	//  A list of tags assigned to your DB instance recommendations.
	Tags []Tag

	//  An array of objects that describe the utilization metrics of the DB instance.
	UtilizationMetrics []RDSDBUtilizationMetric

	noSmithyDocumentSerde
}

func (v *RDSDBRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSDBRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSDBRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.RDSDBRecommendation_accountId, *v.AccountId)
	}
	if v.CurrentDBInstanceClass != nil {
		s.WriteString(schemas.RDSDBRecommendation_currentDBInstanceClass, *v.CurrentDBInstanceClass)
	}
	if v.CurrentInstancePerformanceRisk != "" {
		s.WriteString(schemas.RDSDBRecommendation_currentInstancePerformanceRisk, string(v.CurrentInstancePerformanceRisk))
	}
	if v.CurrentStorageConfiguration != nil {
		s.WriteStruct(schemas.RDSDBRecommendation_currentStorageConfiguration)
		v.CurrentStorageConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CurrentStorageEstimatedMonthlyVolumeIOPsCostVariation != "" {
		s.WriteString(schemas.RDSDBRecommendation_currentStorageEstimatedMonthlyVolumeIOPsCostVariation, string(v.CurrentStorageEstimatedMonthlyVolumeIOPsCostVariation))
	}
	if v.DbClusterIdentifier != nil {
		s.WriteString(schemas.RDSDBRecommendation_dbClusterIdentifier, *v.DbClusterIdentifier)
	}
	if v.EffectiveRecommendationPreferences != nil {
		s.WriteStruct(schemas.RDSDBRecommendation_effectiveRecommendationPreferences)
		v.EffectiveRecommendationPreferences.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Engine != nil {
		s.WriteString(schemas.RDSDBRecommendation_engine, *v.Engine)
	}
	if v.EngineVersion != nil {
		s.WriteString(schemas.RDSDBRecommendation_engineVersion, *v.EngineVersion)
	}
	if v.Idle != "" {
		s.WriteString(schemas.RDSDBRecommendation_idle, string(v.Idle))
	}
	if v.InstanceFinding != "" {
		s.WriteString(schemas.RDSDBRecommendation_instanceFinding, string(v.InstanceFinding))
	}
	serializeRDSInstanceFindingReasonCodes(s, schemas.RDSDBRecommendation_instanceFindingReasonCodes, v.InstanceFindingReasonCodes)
	serializeRDSDBInstanceRecommendationOptions(s, schemas.RDSDBRecommendation_instanceRecommendationOptions, v.InstanceRecommendationOptions)
	if v.LastRefreshTimestamp != nil {
		s.WriteTime(schemas.RDSDBRecommendation_lastRefreshTimestamp, *v.LastRefreshTimestamp)
	}
	if v.LookbackPeriodInDays != 0 {
		s.WriteFloat64(schemas.RDSDBRecommendation_lookbackPeriodInDays, v.LookbackPeriodInDays)
	}
	if v.PromotionTier != nil {
		s.WriteInt32(schemas.RDSDBRecommendation_promotionTier, *v.PromotionTier)
	}
	if v.ResourceArn != nil {
		s.WriteString(schemas.RDSDBRecommendation_resourceArn, *v.ResourceArn)
	}
	if v.StorageFinding != "" {
		s.WriteString(schemas.RDSDBRecommendation_storageFinding, string(v.StorageFinding))
	}
	serializeRDSStorageFindingReasonCodes(s, schemas.RDSDBRecommendation_storageFindingReasonCodes, v.StorageFindingReasonCodes)
	serializeRDSDBStorageRecommendationOptions(s, schemas.RDSDBRecommendation_storageRecommendationOptions, v.StorageRecommendationOptions)
	serializeTags(s, schemas.RDSDBRecommendation_tags, v.Tags)
	serializeRDSDBUtilizationMetrics(s, schemas.RDSDBRecommendation_utilizationMetrics, v.UtilizationMetrics)
}
func (v *RDSDBRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSDBRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSDBRecommendation_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.RDSDBRecommendation_accountId, v.AccountId)
		case schemas.RDSDBRecommendation_currentDBInstanceClass:
			v.CurrentDBInstanceClass = new(string)
			return d.ReadString(schemas.RDSDBRecommendation_currentDBInstanceClass, v.CurrentDBInstanceClass)
		case schemas.RDSDBRecommendation_currentInstancePerformanceRisk:
			var ev string
			if err := d.ReadString(schemas.RDSDBRecommendation_currentInstancePerformanceRisk, &ev); err != nil {
				return err
			}
			v.CurrentInstancePerformanceRisk = RDSCurrentInstancePerformanceRisk(ev)
			return nil
		case schemas.RDSDBRecommendation_currentStorageConfiguration:
			v.CurrentStorageConfiguration = &DBStorageConfiguration{}
			return v.CurrentStorageConfiguration.Deserialize(d)
		case schemas.RDSDBRecommendation_currentStorageEstimatedMonthlyVolumeIOPsCostVariation:
			var ev string
			if err := d.ReadString(schemas.RDSDBRecommendation_currentStorageEstimatedMonthlyVolumeIOPsCostVariation, &ev); err != nil {
				return err
			}
			v.CurrentStorageEstimatedMonthlyVolumeIOPsCostVariation = RDSEstimatedMonthlyVolumeIOPsCostVariation(ev)
			return nil
		case schemas.RDSDBRecommendation_dbClusterIdentifier:
			v.DbClusterIdentifier = new(string)
			return d.ReadString(schemas.RDSDBRecommendation_dbClusterIdentifier, v.DbClusterIdentifier)
		case schemas.RDSDBRecommendation_effectiveRecommendationPreferences:
			v.EffectiveRecommendationPreferences = &RDSEffectiveRecommendationPreferences{}
			return v.EffectiveRecommendationPreferences.Deserialize(d)
		case schemas.RDSDBRecommendation_engine:
			v.Engine = new(string)
			return d.ReadString(schemas.RDSDBRecommendation_engine, v.Engine)
		case schemas.RDSDBRecommendation_engineVersion:
			v.EngineVersion = new(string)
			return d.ReadString(schemas.RDSDBRecommendation_engineVersion, v.EngineVersion)
		case schemas.RDSDBRecommendation_idle:
			var ev string
			if err := d.ReadString(schemas.RDSDBRecommendation_idle, &ev); err != nil {
				return err
			}
			v.Idle = Idle(ev)
			return nil
		case schemas.RDSDBRecommendation_instanceFinding:
			var ev string
			if err := d.ReadString(schemas.RDSDBRecommendation_instanceFinding, &ev); err != nil {
				return err
			}
			v.InstanceFinding = RDSInstanceFinding(ev)
			return nil
		case schemas.RDSDBRecommendation_instanceFindingReasonCodes:
			return deserializeRDSInstanceFindingReasonCodes(d, schemas.RDSDBRecommendation_instanceFindingReasonCodes, &v.InstanceFindingReasonCodes)
		case schemas.RDSDBRecommendation_instanceRecommendationOptions:
			return deserializeRDSDBInstanceRecommendationOptions(d, schemas.RDSDBRecommendation_instanceRecommendationOptions, &v.InstanceRecommendationOptions)
		case schemas.RDSDBRecommendation_lastRefreshTimestamp:
			v.LastRefreshTimestamp = new(time.Time)
			return d.ReadTime(schemas.RDSDBRecommendation_lastRefreshTimestamp, v.LastRefreshTimestamp)
		case schemas.RDSDBRecommendation_lookbackPeriodInDays:
			return d.ReadFloat64(schemas.RDSDBRecommendation_lookbackPeriodInDays, &v.LookbackPeriodInDays)
		case schemas.RDSDBRecommendation_promotionTier:
			v.PromotionTier = new(int32)
			return d.ReadInt32(schemas.RDSDBRecommendation_promotionTier, v.PromotionTier)
		case schemas.RDSDBRecommendation_resourceArn:
			v.ResourceArn = new(string)
			return d.ReadString(schemas.RDSDBRecommendation_resourceArn, v.ResourceArn)
		case schemas.RDSDBRecommendation_storageFinding:
			var ev string
			if err := d.ReadString(schemas.RDSDBRecommendation_storageFinding, &ev); err != nil {
				return err
			}
			v.StorageFinding = RDSStorageFinding(ev)
			return nil
		case schemas.RDSDBRecommendation_storageFindingReasonCodes:
			return deserializeRDSStorageFindingReasonCodes(d, schemas.RDSDBRecommendation_storageFindingReasonCodes, &v.StorageFindingReasonCodes)
		case schemas.RDSDBRecommendation_storageRecommendationOptions:
			return deserializeRDSDBStorageRecommendationOptions(d, schemas.RDSDBRecommendation_storageRecommendationOptions, &v.StorageRecommendationOptions)
		case schemas.RDSDBRecommendation_tags:
			return deserializeTags(d, schemas.RDSDBRecommendation_tags, &v.Tags)
		case schemas.RDSDBRecommendation_utilizationMetrics:
			return deserializeRDSDBUtilizationMetrics(d, schemas.RDSDBRecommendation_utilizationMetrics, &v.UtilizationMetrics)
		}
		return nil
	})
}

//	Describes a filter that returns a more specific list of DB instance
//
// recommendations. Use this filter with the GetECSServiceRecommendationsaction.
type RDSDBRecommendationFilter struct {

	//  The name of the filter.
	//
	// Specify Finding to return recommendations with a specific finding
	// classification.
	//
	// You can filter your DB instance recommendations by tag:key and tag-key tags.
	//
	// A tag:key is a key and value combination of a tag assigned to your DB instance
	// recommendations. Use the tag key in the filter name and the tag value as the
	// filter value. For example, to find all DB instance recommendations that have a
	// tag with the key of Owner and the value of TeamA , specify tag:Owner for the
	// filter name and TeamA for the filter value.
	//
	// A tag-key is the key of a tag assigned to your DB instance recommendations. Use
	// this filter to find all of your DB instance recommendations that have a tag with
	// a specific key. This doesn’t consider the tag value. For example, you can find
	// your DB instance recommendations with a tag key value of Owner or without any
	// tag keys assigned.
	Name RDSDBRecommendationFilterName

	//  The value of the filter.
	Values []string

	noSmithyDocumentSerde
}

func (v *RDSDBRecommendationFilter) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSDBRecommendationFilter)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSDBRecommendationFilter) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.RDSDBRecommendationFilter_name, string(v.Name))
	}
	serializeFilterValues(s, schemas.RDSDBRecommendationFilter_values, v.Values)
}
func (v *RDSDBRecommendationFilter) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSDBRecommendationFilter, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSDBRecommendationFilter_name:
			var ev string
			if err := d.ReadString(schemas.RDSDBRecommendationFilter_name, &ev); err != nil {
				return err
			}
			v.Name = RDSDBRecommendationFilterName(ev)
			return nil
		case schemas.RDSDBRecommendationFilter_values:
			return deserializeFilterValues(d, schemas.RDSDBRecommendationFilter_values, &v.Values)
		}
		return nil
	})
}

// Describes the recommendation options for DB storage.
type RDSDBStorageRecommendationOption struct {

	//  The projected level of variation in monthly I/O costs for the DB storage
	// recommendation option.
	EstimatedMonthlyVolumeIOPsCostVariation RDSEstimatedMonthlyVolumeIOPsCostVariation

	//  The rank identifier of the DB storage recommendation option.
	Rank int32

	// Describes the savings opportunity for recommendations of a given resource type
	// or for the recommendation option of an individual resource.
	//
	// Savings opportunity represents the estimated monthly savings you can achieve by
	// implementing a given Compute Optimizer recommendation.
	//
	// Savings opportunity data requires that you opt in to Cost Explorer, as well as
	// activate Receive Amazon EC2 resource recommendations in the Cost Explorer
	// preferences page. That creates a connection between Cost Explorer and Compute
	// Optimizer. With this connection, Cost Explorer generates savings estimates
	// considering the price of existing resources, the price of recommended resources,
	// and historical usage data. Estimated monthly savings reflects the projected
	// dollar savings associated with each of the recommendations generated. For more
	// information, see [Enabling Cost Explorer]and [Optimizing your cost with Rightsizing Recommendations] in the Cost Management User Guide.
	//
	// [Optimizing your cost with Rightsizing Recommendations]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-rightsizing.html
	// [Enabling Cost Explorer]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-enable.html
	SavingsOpportunity *SavingsOpportunity

	//  Describes the savings opportunity for DB storage recommendations or for the
	// recommendation option.
	//
	// Savings opportunity represents the estimated monthly savings after applying
	// Savings Plans discounts. You can achieve this by implementing a given Compute
	// Optimizer recommendation.
	SavingsOpportunityAfterDiscounts *RDSStorageSavingsOpportunityAfterDiscounts

	//  The recommended storage configuration.
	StorageConfiguration *DBStorageConfiguration

	noSmithyDocumentSerde
}

func (v *RDSDBStorageRecommendationOption) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSDBStorageRecommendationOption)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSDBStorageRecommendationOption) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlyVolumeIOPsCostVariation != "" {
		s.WriteString(schemas.RDSDBStorageRecommendationOption_estimatedMonthlyVolumeIOPsCostVariation, string(v.EstimatedMonthlyVolumeIOPsCostVariation))
	}
	if v.Rank != 0 {
		s.WriteInt32(schemas.RDSDBStorageRecommendationOption_rank, v.Rank)
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.RDSDBStorageRecommendationOption_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityAfterDiscounts != nil {
		s.WriteStruct(schemas.RDSDBStorageRecommendationOption_savingsOpportunityAfterDiscounts)
		v.SavingsOpportunityAfterDiscounts.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.StorageConfiguration != nil {
		s.WriteStruct(schemas.RDSDBStorageRecommendationOption_storageConfiguration)
		v.StorageConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *RDSDBStorageRecommendationOption) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSDBStorageRecommendationOption, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSDBStorageRecommendationOption_estimatedMonthlyVolumeIOPsCostVariation:
			var ev string
			if err := d.ReadString(schemas.RDSDBStorageRecommendationOption_estimatedMonthlyVolumeIOPsCostVariation, &ev); err != nil {
				return err
			}
			v.EstimatedMonthlyVolumeIOPsCostVariation = RDSEstimatedMonthlyVolumeIOPsCostVariation(ev)
			return nil
		case schemas.RDSDBStorageRecommendationOption_rank:
			return d.ReadInt32(schemas.RDSDBStorageRecommendationOption_rank, &v.Rank)
		case schemas.RDSDBStorageRecommendationOption_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.RDSDBStorageRecommendationOption_savingsOpportunityAfterDiscounts:
			v.SavingsOpportunityAfterDiscounts = &RDSStorageSavingsOpportunityAfterDiscounts{}
			return v.SavingsOpportunityAfterDiscounts.Deserialize(d)
		case schemas.RDSDBStorageRecommendationOption_storageConfiguration:
			v.StorageConfiguration = &DBStorageConfiguration{}
			return v.StorageConfiguration.Deserialize(d)
		}
		return nil
	})
}

//	Describes the utilization metric of an Amazon Aurora and RDS database.
//
// To determine the performance difference between your current DB instance and
// the recommended option, compare the utilization metric data of your service
// against its projected utilization metric data.
type RDSDBUtilizationMetric struct {

	//  The name of the utilization metric.
	Name RDSDBMetricName

	//  The statistic of the utilization metric.
	//
	// The Compute Optimizer API, Command Line Interface (CLI), and SDKs return
	// utilization metrics using only the Maximum statistic, which is the highest
	// value observed during the specified period.
	//
	// The Compute Optimizer console displays graphs for some utilization metrics
	// using the Average statistic, which is the value of Sum / SampleCount during the
	// specified period. For more information, see [Viewing resource recommendations]in the Compute Optimizer User
	// Guide. You can also get averaged utilization metric data for your resources
	// using Amazon CloudWatch. For more information, see the [Amazon CloudWatch User Guide].
	//
	// [Viewing resource recommendations]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/viewing-recommendations.html
	// [Amazon CloudWatch User Guide]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html
	Statistic RDSDBMetricStatistic

	//  The value of the utilization metric.
	Value float64

	noSmithyDocumentSerde
}

func (v *RDSDBUtilizationMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSDBUtilizationMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSDBUtilizationMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.RDSDBUtilizationMetric_name, string(v.Name))
	}
	if v.Statistic != "" {
		s.WriteString(schemas.RDSDBUtilizationMetric_statistic, string(v.Statistic))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.RDSDBUtilizationMetric_value, v.Value)
	}
}
func (v *RDSDBUtilizationMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSDBUtilizationMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSDBUtilizationMetric_name:
			var ev string
			if err := d.ReadString(schemas.RDSDBUtilizationMetric_name, &ev); err != nil {
				return err
			}
			v.Name = RDSDBMetricName(ev)
			return nil
		case schemas.RDSDBUtilizationMetric_statistic:
			var ev string
			if err := d.ReadString(schemas.RDSDBUtilizationMetric_statistic, &ev); err != nil {
				return err
			}
			v.Statistic = RDSDBMetricStatistic(ev)
			return nil
		case schemas.RDSDBUtilizationMetric_value:
			return d.ReadFloat64(schemas.RDSDBUtilizationMetric_value, &v.Value)
		}
		return nil
	})
}

//	Describes the effective recommendation preferences for Amazon Aurora and RDS
//
// databases.
type RDSEffectiveRecommendationPreferences struct {

	//  Describes the CPU vendor and architecture for DB instance recommendations.
	CpuVendorArchitectures []CpuVendorArchitecture

	// Describes the activation status of the enhanced infrastructure metrics
	// preference.
	//
	// A status of Active confirms that the preference is applied in the latest
	// recommendation refresh, and a status of Inactive confirms that it's not yet
	// applied to recommendations.
	//
	// For more information, see [Enhanced infrastructure metrics] in the Compute Optimizer User Guide.
	//
	// [Enhanced infrastructure metrics]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/enhanced-infrastructure-metrics.html
	EnhancedInfrastructureMetrics EnhancedInfrastructureMetrics

	//  The number of days the utilization metrics of the DB instance are analyzed.
	LookBackPeriod LookBackPeriodPreference

	//  Describes the savings estimation mode preference applied for calculating
	// savings opportunity for DB instances.
	SavingsEstimationMode *RDSSavingsEstimationMode

	noSmithyDocumentSerde
}

func (v *RDSEffectiveRecommendationPreferences) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSEffectiveRecommendationPreferences)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSEffectiveRecommendationPreferences) SerializeMembers(s smithy.ShapeSerializer) {
	serializeCpuVendorArchitectures(s, schemas.RDSEffectiveRecommendationPreferences_cpuVendorArchitectures, v.CpuVendorArchitectures)
	if v.EnhancedInfrastructureMetrics != "" {
		s.WriteString(schemas.RDSEffectiveRecommendationPreferences_enhancedInfrastructureMetrics, string(v.EnhancedInfrastructureMetrics))
	}
	if v.LookBackPeriod != "" {
		s.WriteString(schemas.RDSEffectiveRecommendationPreferences_lookBackPeriod, string(v.LookBackPeriod))
	}
	if v.SavingsEstimationMode != nil {
		s.WriteStruct(schemas.RDSEffectiveRecommendationPreferences_savingsEstimationMode)
		v.SavingsEstimationMode.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *RDSEffectiveRecommendationPreferences) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSEffectiveRecommendationPreferences, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSEffectiveRecommendationPreferences_cpuVendorArchitectures:
			return deserializeCpuVendorArchitectures(d, schemas.RDSEffectiveRecommendationPreferences_cpuVendorArchitectures, &v.CpuVendorArchitectures)
		case schemas.RDSEffectiveRecommendationPreferences_enhancedInfrastructureMetrics:
			var ev string
			if err := d.ReadString(schemas.RDSEffectiveRecommendationPreferences_enhancedInfrastructureMetrics, &ev); err != nil {
				return err
			}
			v.EnhancedInfrastructureMetrics = EnhancedInfrastructureMetrics(ev)
			return nil
		case schemas.RDSEffectiveRecommendationPreferences_lookBackPeriod:
			var ev string
			if err := d.ReadString(schemas.RDSEffectiveRecommendationPreferences_lookBackPeriod, &ev); err != nil {
				return err
			}
			v.LookBackPeriod = LookBackPeriodPreference(ev)
			return nil
		case schemas.RDSEffectiveRecommendationPreferences_savingsEstimationMode:
			v.SavingsEstimationMode = &RDSSavingsEstimationMode{}
			return v.SavingsEstimationMode.Deserialize(d)
		}
		return nil
	})
}

//	Describes the estimated monthly savings possible for DB instances by adopting
//
// Compute Optimizer recommendations. This is based on DB instance pricing after
// applying Savings Plans discounts.
type RDSInstanceEstimatedMonthlySavings struct {

	//  The currency of the estimated monthly savings.
	Currency Currency

	//  The value of the estimated monthly savings for DB instances.
	Value float64

	noSmithyDocumentSerde
}

func (v *RDSInstanceEstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSInstanceEstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSInstanceEstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.RDSInstanceEstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.RDSInstanceEstimatedMonthlySavings_value, v.Value)
	}
}
func (v *RDSInstanceEstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSInstanceEstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSInstanceEstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.RDSInstanceEstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.RDSInstanceEstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.RDSInstanceEstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

//	Describes the savings opportunity for DB instance recommendations after
//
// applying Savings Plans discounts.
//
// Savings opportunity represents the estimated monthly savings after applying
// Savings Plans discounts. You can achieve this by implementing a given Compute
// Optimizer recommendation.
type RDSInstanceSavingsOpportunityAfterDiscounts struct {

	//  The estimated monthly savings possible by adopting Compute Optimizer’s DB
	// instance recommendations. This includes any applicable Savings Plans discounts.
	EstimatedMonthlySavings *RDSInstanceEstimatedMonthlySavings

	//  The estimated monthly savings possible as a percentage of monthly cost by
	// adopting Compute Optimizer’s DB instance recommendations. This includes any
	// applicable Savings Plans discounts.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *RDSInstanceSavingsOpportunityAfterDiscounts) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSInstanceSavingsOpportunityAfterDiscounts)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSInstanceSavingsOpportunityAfterDiscounts) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.RDSInstanceSavingsOpportunityAfterDiscounts_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.RDSInstanceSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *RDSInstanceSavingsOpportunityAfterDiscounts) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSInstanceSavingsOpportunityAfterDiscounts, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSInstanceSavingsOpportunityAfterDiscounts_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &RDSInstanceEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.RDSInstanceSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.RDSInstanceSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

//	Describes the savings estimation mode used for calculating savings opportunity
//
// for DB instances.
type RDSSavingsEstimationMode struct {

	//  Describes the source for calculating the savings opportunity for DB instances.
	Source RDSSavingsEstimationModeSource

	noSmithyDocumentSerde
}

func (v *RDSSavingsEstimationMode) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSSavingsEstimationMode)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSSavingsEstimationMode) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Source != "" {
		s.WriteString(schemas.RDSSavingsEstimationMode_source, string(v.Source))
	}
}
func (v *RDSSavingsEstimationMode) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSSavingsEstimationMode, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSSavingsEstimationMode_source:
			var ev string
			if err := d.ReadString(schemas.RDSSavingsEstimationMode_source, &ev); err != nil {
				return err
			}
			v.Source = RDSSavingsEstimationModeSource(ev)
			return nil
		}
		return nil
	})
}

//	Describes the estimated monthly savings possible for DB instance storage by
//
// adopting Compute Optimizer recommendations. This is based on DB instance pricing
// after applying Savings Plans discounts.
type RDSStorageEstimatedMonthlySavings struct {

	//  The currency of the estimated monthly savings.
	Currency Currency

	//  The value of the estimated monthly savings for DB instance storage.
	Value float64

	noSmithyDocumentSerde
}

func (v *RDSStorageEstimatedMonthlySavings) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSStorageEstimatedMonthlySavings)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSStorageEstimatedMonthlySavings) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Currency != "" {
		s.WriteString(schemas.RDSStorageEstimatedMonthlySavings_currency, string(v.Currency))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.RDSStorageEstimatedMonthlySavings_value, v.Value)
	}
}
func (v *RDSStorageEstimatedMonthlySavings) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSStorageEstimatedMonthlySavings, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSStorageEstimatedMonthlySavings_currency:
			var ev string
			if err := d.ReadString(schemas.RDSStorageEstimatedMonthlySavings_currency, &ev); err != nil {
				return err
			}
			v.Currency = Currency(ev)
			return nil
		case schemas.RDSStorageEstimatedMonthlySavings_value:
			return d.ReadFloat64(schemas.RDSStorageEstimatedMonthlySavings_value, &v.Value)
		}
		return nil
	})
}

//	Describes the savings opportunity for Amazon RDS storage recommendations after
//
// applying Savings Plans discounts.
//
// Savings opportunity represents the estimated monthly savings after applying
// Savings Plans discounts. You can achieve this by implementing a given Compute
// Optimizer recommendation.
type RDSStorageSavingsOpportunityAfterDiscounts struct {

	//  The estimated monthly savings possible by adopting Compute Optimizer’s DB
	// instance storage recommendations. This includes any applicable Savings Plans
	// discounts.
	EstimatedMonthlySavings *RDSStorageEstimatedMonthlySavings

	//  The estimated monthly savings possible as a percentage of monthly cost by
	// adopting Compute Optimizer’s DB instance storage recommendations. This includes
	// any applicable Savings Plans discounts.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *RDSStorageSavingsOpportunityAfterDiscounts) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RDSStorageSavingsOpportunityAfterDiscounts)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RDSStorageSavingsOpportunityAfterDiscounts) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.RDSStorageSavingsOpportunityAfterDiscounts_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.RDSStorageSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *RDSStorageSavingsOpportunityAfterDiscounts) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RDSStorageSavingsOpportunityAfterDiscounts, func(s *smithy.Schema) error {
		switch s {
		case schemas.RDSStorageSavingsOpportunityAfterDiscounts_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &RDSStorageEstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.RDSStorageSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.RDSStorageSavingsOpportunityAfterDiscounts_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

// A summary of a finding reason code.
type ReasonCodeSummary struct {

	// The name of the finding reason code.
	Name FindingReasonCode

	// The value of the finding reason code summary.
	Value float64

	noSmithyDocumentSerde
}

func (v *ReasonCodeSummary) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ReasonCodeSummary)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ReasonCodeSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.ReasonCodeSummary_name, string(v.Name))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.ReasonCodeSummary_value, v.Value)
	}
}
func (v *ReasonCodeSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ReasonCodeSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.ReasonCodeSummary_name:
			var ev string
			if err := d.ReadString(schemas.ReasonCodeSummary_name, &ev); err != nil {
				return err
			}
			v.Name = FindingReasonCode(ev)
			return nil
		case schemas.ReasonCodeSummary_value:
			return d.ReadFloat64(schemas.ReasonCodeSummary_value, &v.Value)
		}
		return nil
	})
}

// Describes a recommendation export job.
//
// Use the DescribeRecommendationExportJobs action to view your recommendation export jobs.
//
// Use the ExportAutoScalingGroupRecommendations or ExportEC2InstanceRecommendations actions to request an export of your recommendations.
type RecommendationExportJob struct {

	// The timestamp of when the export job was created.
	CreationTimestamp *time.Time

	// An object that describes the destination of the export file.
	Destination *ExportDestination

	// The reason for an export job failure.
	FailureReason *string

	// The identification number of the export job.
	JobId *string

	// The timestamp of when the export job was last updated.
	LastUpdatedTimestamp *time.Time

	// The resource type of the exported recommendations.
	ResourceType ResourceType

	// The status of the export job.
	Status JobStatus

	noSmithyDocumentSerde
}

func (v *RecommendationExportJob) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RecommendationExportJob)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RecommendationExportJob) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CreationTimestamp != nil {
		s.WriteTime(schemas.RecommendationExportJob_creationTimestamp, *v.CreationTimestamp)
	}
	if v.Destination != nil {
		s.WriteStruct(schemas.RecommendationExportJob_destination)
		v.Destination.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.FailureReason != nil {
		s.WriteString(schemas.RecommendationExportJob_failureReason, *v.FailureReason)
	}
	if v.JobId != nil {
		s.WriteString(schemas.RecommendationExportJob_jobId, *v.JobId)
	}
	if v.LastUpdatedTimestamp != nil {
		s.WriteTime(schemas.RecommendationExportJob_lastUpdatedTimestamp, *v.LastUpdatedTimestamp)
	}
	if v.ResourceType != "" {
		s.WriteString(schemas.RecommendationExportJob_resourceType, string(v.ResourceType))
	}
	if v.Status != "" {
		s.WriteString(schemas.RecommendationExportJob_status, string(v.Status))
	}
}
func (v *RecommendationExportJob) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RecommendationExportJob, func(s *smithy.Schema) error {
		switch s {
		case schemas.RecommendationExportJob_creationTimestamp:
			v.CreationTimestamp = new(time.Time)
			return d.ReadTime(schemas.RecommendationExportJob_creationTimestamp, v.CreationTimestamp)
		case schemas.RecommendationExportJob_destination:
			v.Destination = &ExportDestination{}
			return v.Destination.Deserialize(d)
		case schemas.RecommendationExportJob_failureReason:
			v.FailureReason = new(string)
			return d.ReadString(schemas.RecommendationExportJob_failureReason, v.FailureReason)
		case schemas.RecommendationExportJob_jobId:
			v.JobId = new(string)
			return d.ReadString(schemas.RecommendationExportJob_jobId, v.JobId)
		case schemas.RecommendationExportJob_lastUpdatedTimestamp:
			v.LastUpdatedTimestamp = new(time.Time)
			return d.ReadTime(schemas.RecommendationExportJob_lastUpdatedTimestamp, v.LastUpdatedTimestamp)
		case schemas.RecommendationExportJob_resourceType:
			var ev string
			if err := d.ReadString(schemas.RecommendationExportJob_resourceType, &ev); err != nil {
				return err
			}
			v.ResourceType = ResourceType(ev)
			return nil
		case schemas.RecommendationExportJob_status:
			var ev string
			if err := d.ReadString(schemas.RecommendationExportJob_status, &ev); err != nil {
				return err
			}
			v.Status = JobStatus(ev)
			return nil
		}
		return nil
	})
}

// Describes the recommendation preferences to return in the response of a GetAutoScalingGroupRecommendations, GetEC2InstanceRecommendations, GetEC2RecommendationProjectedMetrics, GetRDSDatabaseRecommendations,
// and GetRDSDatabaseRecommendationProjectedMetricsrequest.
type RecommendationPreferences struct {

	// Specifies the CPU vendor and architecture for Amazon EC2 instance and Auto
	// Scaling group recommendations.
	//
	// For example, when you specify AWS_ARM64 with:
	//
	//   - A GetEC2InstanceRecommendationsor GetAutoScalingGroupRecommendationsrequest, Compute Optimizer returns recommendations that consist of
	//   Graviton instance types only.
	//
	//   - A GetEC2RecommendationProjectedMetricsrequest, Compute Optimizer returns projected utilization metrics for
	//   Graviton instance type recommendations only.
	//
	//   - A ExportEC2InstanceRecommendationsor ExportAutoScalingGroupRecommendationsrequest, Compute Optimizer exports recommendations that consist of
	//   Graviton instance types only.
	CpuVendorArchitectures []CpuVendorArchitecture

	noSmithyDocumentSerde
}

func (v *RecommendationPreferences) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RecommendationPreferences)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RecommendationPreferences) SerializeMembers(s smithy.ShapeSerializer) {
	serializeCpuVendorArchitectures(s, schemas.RecommendationPreferences_cpuVendorArchitectures, v.CpuVendorArchitectures)
}
func (v *RecommendationPreferences) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RecommendationPreferences, func(s *smithy.Schema) error {
		switch s {
		case schemas.RecommendationPreferences_cpuVendorArchitectures:
			return deserializeCpuVendorArchitectures(d, schemas.RecommendationPreferences_cpuVendorArchitectures, &v.CpuVendorArchitectures)
		}
		return nil
	})
}

// Describes a recommendation preference.
type RecommendationPreferencesDetail struct {

	// The status of the enhanced infrastructure metrics recommendation preference.
	//
	// When the recommendations page is refreshed, a status of Active confirms that
	// the preference is applied to the recommendations, and a status of Inactive
	// confirms that the preference isn't yet applied to recommendations.
	//
	// For more information, see [Enhanced infrastructure metrics] in the Compute Optimizer User Guide.
	//
	// [Enhanced infrastructure metrics]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/enhanced-infrastructure-metrics.html
	EnhancedInfrastructureMetrics EnhancedInfrastructureMetrics

	//  An object that describes the external metrics recommendation preference.
	//
	// If the preference is applied in the latest recommendation refresh, an object
	// with a valid source value appears in the response. If the preference isn't
	// applied to the recommendations already, then this object doesn't appear in the
	// response.
	ExternalMetricsPreference *ExternalMetricsPreference

	// The status of the inferred workload types recommendation preference.
	//
	// When the recommendations page is refreshed, a status of Active confirms that
	// the preference is applied to the recommendations, and a status of Inactive
	// confirms that the preference isn't yet applied to recommendations.
	InferredWorkloadTypes InferredWorkloadTypesPreference

	//  The preference to control the number of days the utilization metrics of the
	// Amazon Web Services resource are analyzed. If the preference isn’t set, this
	// object is null.
	LookBackPeriod LookBackPeriodPreference

	//  The preference to control which resource type values are considered when
	// generating rightsizing recommendations. This object resolves any wildcard
	// expressions and returns the effective list of candidate resource type values. If
	// the preference isn’t set, this object is null.
	PreferredResources []EffectivePreferredResource

	// The target resource type of the recommendation preference to create.
	//
	// The Ec2Instance option encompasses standalone instances and instances that are
	// part of Auto Scaling groups. The AutoScalingGroup option encompasses only
	// instances that are part of an Auto Scaling group.
	ResourceType ResourceType

	//  Describes the savings estimation mode used for calculating savings
	// opportunity.
	//
	// Only the account manager or delegated administrator of your organization can
	// activate this preference.
	SavingsEstimationMode SavingsEstimationMode

	// An object that describes the scope of the recommendation preference.
	//
	// Recommendation preferences can be created at the organization level (for
	// management accounts of an organization only), account level, and resource level.
	// For more information, see [Activating enhanced infrastructure metrics]in the Compute Optimizer User Guide.
	//
	// [Activating enhanced infrastructure metrics]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/enhanced-infrastructure-metrics.html
	Scope *Scope

	//  The preference to control the resource’s CPU utilization threshold, CPU
	// utilization headroom, and memory utilization headroom. If the preference isn’t
	// set, this object is null.
	//
	// This preference is only available for the Amazon EC2 instance resource type.
	UtilizationPreferences []UtilizationPreference

	noSmithyDocumentSerde
}

func (v *RecommendationPreferencesDetail) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RecommendationPreferencesDetail)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RecommendationPreferencesDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EnhancedInfrastructureMetrics != "" {
		s.WriteString(schemas.RecommendationPreferencesDetail_enhancedInfrastructureMetrics, string(v.EnhancedInfrastructureMetrics))
	}
	if v.ExternalMetricsPreference != nil {
		s.WriteStruct(schemas.RecommendationPreferencesDetail_externalMetricsPreference)
		v.ExternalMetricsPreference.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.InferredWorkloadTypes != "" {
		s.WriteString(schemas.RecommendationPreferencesDetail_inferredWorkloadTypes, string(v.InferredWorkloadTypes))
	}
	if v.LookBackPeriod != "" {
		s.WriteString(schemas.RecommendationPreferencesDetail_lookBackPeriod, string(v.LookBackPeriod))
	}
	serializeEffectivePreferredResources(s, schemas.RecommendationPreferencesDetail_preferredResources, v.PreferredResources)
	if v.ResourceType != "" {
		s.WriteString(schemas.RecommendationPreferencesDetail_resourceType, string(v.ResourceType))
	}
	if v.SavingsEstimationMode != "" {
		s.WriteString(schemas.RecommendationPreferencesDetail_savingsEstimationMode, string(v.SavingsEstimationMode))
	}
	if v.Scope != nil {
		s.WriteStruct(schemas.RecommendationPreferencesDetail_scope)
		v.Scope.SerializeMembers(s)
		s.CloseStruct()
	}
	serializeUtilizationPreferences(s, schemas.RecommendationPreferencesDetail_utilizationPreferences, v.UtilizationPreferences)
}
func (v *RecommendationPreferencesDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RecommendationPreferencesDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.RecommendationPreferencesDetail_enhancedInfrastructureMetrics:
			var ev string
			if err := d.ReadString(schemas.RecommendationPreferencesDetail_enhancedInfrastructureMetrics, &ev); err != nil {
				return err
			}
			v.EnhancedInfrastructureMetrics = EnhancedInfrastructureMetrics(ev)
			return nil
		case schemas.RecommendationPreferencesDetail_externalMetricsPreference:
			v.ExternalMetricsPreference = &ExternalMetricsPreference{}
			return v.ExternalMetricsPreference.Deserialize(d)
		case schemas.RecommendationPreferencesDetail_inferredWorkloadTypes:
			var ev string
			if err := d.ReadString(schemas.RecommendationPreferencesDetail_inferredWorkloadTypes, &ev); err != nil {
				return err
			}
			v.InferredWorkloadTypes = InferredWorkloadTypesPreference(ev)
			return nil
		case schemas.RecommendationPreferencesDetail_lookBackPeriod:
			var ev string
			if err := d.ReadString(schemas.RecommendationPreferencesDetail_lookBackPeriod, &ev); err != nil {
				return err
			}
			v.LookBackPeriod = LookBackPeriodPreference(ev)
			return nil
		case schemas.RecommendationPreferencesDetail_preferredResources:
			return deserializeEffectivePreferredResources(d, schemas.RecommendationPreferencesDetail_preferredResources, &v.PreferredResources)
		case schemas.RecommendationPreferencesDetail_resourceType:
			var ev string
			if err := d.ReadString(schemas.RecommendationPreferencesDetail_resourceType, &ev); err != nil {
				return err
			}
			v.ResourceType = ResourceType(ev)
			return nil
		case schemas.RecommendationPreferencesDetail_savingsEstimationMode:
			var ev string
			if err := d.ReadString(schemas.RecommendationPreferencesDetail_savingsEstimationMode, &ev); err != nil {
				return err
			}
			v.SavingsEstimationMode = SavingsEstimationMode(ev)
			return nil
		case schemas.RecommendationPreferencesDetail_scope:
			v.Scope = &Scope{}
			return v.Scope.Deserialize(d)
		case schemas.RecommendationPreferencesDetail_utilizationPreferences:
			return deserializeUtilizationPreferences(d, schemas.RecommendationPreferencesDetail_utilizationPreferences, &v.UtilizationPreferences)
		}
		return nil
	})
}

// Describes the source of a recommendation, such as an Amazon EC2 instance or
// Auto Scaling group.
type RecommendationSource struct {

	// The Amazon Resource Name (ARN) of the recommendation source.
	RecommendationSourceArn *string

	// The resource type of the recommendation source.
	RecommendationSourceType RecommendationSourceType

	noSmithyDocumentSerde
}

func (v *RecommendationSource) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RecommendationSource)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RecommendationSource) SerializeMembers(s smithy.ShapeSerializer) {
	if v.RecommendationSourceArn != nil {
		s.WriteString(schemas.RecommendationSource_recommendationSourceArn, *v.RecommendationSourceArn)
	}
	if v.RecommendationSourceType != "" {
		s.WriteString(schemas.RecommendationSource_recommendationSourceType, string(v.RecommendationSourceType))
	}
}
func (v *RecommendationSource) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RecommendationSource, func(s *smithy.Schema) error {
		switch s {
		case schemas.RecommendationSource_recommendationSourceArn:
			v.RecommendationSourceArn = new(string)
			return d.ReadString(schemas.RecommendationSource_recommendationSourceArn, v.RecommendationSourceArn)
		case schemas.RecommendationSource_recommendationSourceType:
			var ev string
			if err := d.ReadString(schemas.RecommendationSource_recommendationSourceType, &ev); err != nil {
				return err
			}
			v.RecommendationSourceType = RecommendationSourceType(ev)
			return nil
		}
		return nil
	})
}

// A summary of a recommendation.
type RecommendationSummary struct {

	// The Amazon Web Services account ID of the recommendation summary.
	AccountId *string

	// Describes the savings opportunity for recommendations of a given resource type
	// or for the recommendation option of an individual resource.
	//
	// Savings opportunity represents the estimated monthly savings you can achieve by
	// implementing a given Compute Optimizer recommendation.
	//
	// Savings opportunity data requires that you opt in to Cost Explorer, as well as
	// activate Receive Amazon EC2 resource recommendations in the Cost Explorer
	// preferences page. That creates a connection between Cost Explorer and Compute
	// Optimizer. With this connection, Cost Explorer generates savings estimates
	// considering the price of existing resources, the price of recommended resources,
	// and historical usage data. Estimated monthly savings reflects the projected
	// dollar savings associated with each of the recommendations generated. For more
	// information, see [Enabling Cost Explorer]and [Optimizing your cost with Rightsizing Recommendations] in the Cost Management User Guide.
	//
	// [Optimizing your cost with Rightsizing Recommendations]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-rightsizing.html
	// [Enabling Cost Explorer]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-enable.html
	AggregatedSavingsOpportunity *SavingsOpportunity

	// An object that describes the performance risk ratings for a given resource type.
	CurrentPerformanceRiskRatings *CurrentPerformanceRiskRatings

	// Describes the savings opportunity for recommendations of a given resource type
	// or for the recommendation option of an individual resource.
	//
	// Savings opportunity represents the estimated monthly savings you can achieve by
	// implementing a given Compute Optimizer recommendation.
	//
	// Savings opportunity data requires that you opt in to Cost Explorer, as well as
	// activate Receive Amazon EC2 resource recommendations in the Cost Explorer
	// preferences page. That creates a connection between Cost Explorer and Compute
	// Optimizer. With this connection, Cost Explorer generates savings estimates
	// considering the price of existing resources, the price of recommended resources,
	// and historical usage data. Estimated monthly savings reflects the projected
	// dollar savings associated with each of the recommendations generated. For more
	// information, see [Enabling Cost Explorer]and [Optimizing your cost with Rightsizing Recommendations] in the Cost Management User Guide.
	//
	// [Optimizing your cost with Rightsizing Recommendations]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-rightsizing.html
	// [Enabling Cost Explorer]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-enable.html
	IdleSavingsOpportunity *SavingsOpportunity

	//  Describes the findings summary of the idle resources.
	IdleSummaries []IdleSummary

	//  An array of objects that describes the estimated monthly saving amounts for
	// the instances running on the specified inferredWorkloadTypes . The array
	// contains the top five savings opportunites for the instances that run inferred
	// workload types.
	InferredWorkloadSavings []InferredWorkloadSaving

	// The resource type that the recommendation summary applies to.
	RecommendationResourceType RecommendationSourceType

	// An object that describes the savings opportunity for a given resource type.
	// Savings opportunity includes the estimated monthly savings amount and
	// percentage.
	SavingsOpportunity *SavingsOpportunity

	// An array of objects that describe a recommendation summary.
	Summaries []Summary

	noSmithyDocumentSerde
}

func (v *RecommendationSummary) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RecommendationSummary)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RecommendationSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.RecommendationSummary_accountId, *v.AccountId)
	}
	if v.AggregatedSavingsOpportunity != nil {
		s.WriteStruct(schemas.RecommendationSummary_aggregatedSavingsOpportunity)
		v.AggregatedSavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CurrentPerformanceRiskRatings != nil {
		s.WriteStruct(schemas.RecommendationSummary_currentPerformanceRiskRatings)
		v.CurrentPerformanceRiskRatings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.IdleSavingsOpportunity != nil {
		s.WriteStruct(schemas.RecommendationSummary_idleSavingsOpportunity)
		v.IdleSavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	serializeIdleSummaries(s, schemas.RecommendationSummary_idleSummaries, v.IdleSummaries)
	serializeInferredWorkloadSavings(s, schemas.RecommendationSummary_inferredWorkloadSavings, v.InferredWorkloadSavings)
	if v.RecommendationResourceType != "" {
		s.WriteString(schemas.RecommendationSummary_recommendationResourceType, string(v.RecommendationResourceType))
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.RecommendationSummary_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	serializeSummaries(s, schemas.RecommendationSummary_summaries, v.Summaries)
}
func (v *RecommendationSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RecommendationSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.RecommendationSummary_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.RecommendationSummary_accountId, v.AccountId)
		case schemas.RecommendationSummary_aggregatedSavingsOpportunity:
			v.AggregatedSavingsOpportunity = &SavingsOpportunity{}
			return v.AggregatedSavingsOpportunity.Deserialize(d)
		case schemas.RecommendationSummary_currentPerformanceRiskRatings:
			v.CurrentPerformanceRiskRatings = &CurrentPerformanceRiskRatings{}
			return v.CurrentPerformanceRiskRatings.Deserialize(d)
		case schemas.RecommendationSummary_idleSavingsOpportunity:
			v.IdleSavingsOpportunity = &SavingsOpportunity{}
			return v.IdleSavingsOpportunity.Deserialize(d)
		case schemas.RecommendationSummary_idleSummaries:
			return deserializeIdleSummaries(d, schemas.RecommendationSummary_idleSummaries, &v.IdleSummaries)
		case schemas.RecommendationSummary_inferredWorkloadSavings:
			return deserializeInferredWorkloadSavings(d, schemas.RecommendationSummary_inferredWorkloadSavings, &v.InferredWorkloadSavings)
		case schemas.RecommendationSummary_recommendationResourceType:
			var ev string
			if err := d.ReadString(schemas.RecommendationSummary_recommendationResourceType, &ev); err != nil {
				return err
			}
			v.RecommendationResourceType = RecommendationSourceType(ev)
			return nil
		case schemas.RecommendationSummary_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.RecommendationSummary_summaries:
			return deserializeSummaries(d, schemas.RecommendationSummary_summaries, &v.Summaries)
		}
		return nil
	})
}

// Describes a projected utilization metric of a recommendation option.
//
// The Cpu and Memory metrics are the only projected utilization metrics returned
// when you run the GetEC2RecommendationProjectedMetricsaction. Additionally, the Memory metric is returned only for
// resources that have the unified CloudWatch agent installed on them. For more
// information, see [Enabling Memory Utilization with the CloudWatch Agent].
//
// [Enabling Memory Utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#cw-agent
type RecommendedOptionProjectedMetric struct {

	// An array of objects that describe a projected utilization metric.
	ProjectedMetrics []ProjectedMetric

	// The rank of the recommendation option projected metric.
	//
	// The top recommendation option is ranked as 1 .
	//
	// The projected metric rank correlates to the recommendation option rank. For
	// example, the projected metric ranked as 1 is related to the recommendation
	// option that is also ranked as 1 in the same response.
	Rank int32

	// The recommended instance type.
	RecommendedInstanceType *string

	noSmithyDocumentSerde
}

func (v *RecommendedOptionProjectedMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.RecommendedOptionProjectedMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *RecommendedOptionProjectedMetric) SerializeMembers(s smithy.ShapeSerializer) {
	serializeProjectedMetrics(s, schemas.RecommendedOptionProjectedMetric_projectedMetrics, v.ProjectedMetrics)
	if v.Rank != 0 {
		s.WriteInt32(schemas.RecommendedOptionProjectedMetric_rank, v.Rank)
	}
	if v.RecommendedInstanceType != nil {
		s.WriteString(schemas.RecommendedOptionProjectedMetric_recommendedInstanceType, *v.RecommendedInstanceType)
	}
}
func (v *RecommendedOptionProjectedMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RecommendedOptionProjectedMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.RecommendedOptionProjectedMetric_projectedMetrics:
			return deserializeProjectedMetrics(d, schemas.RecommendedOptionProjectedMetric_projectedMetrics, &v.ProjectedMetrics)
		case schemas.RecommendedOptionProjectedMetric_rank:
			return d.ReadInt32(schemas.RecommendedOptionProjectedMetric_rank, &v.Rank)
		case schemas.RecommendedOptionProjectedMetric_recommendedInstanceType:
			v.RecommendedInstanceType = new(string)
			return d.ReadString(schemas.RecommendedOptionProjectedMetric_recommendedInstanceType, v.RecommendedInstanceType)
		}
		return nil
	})
}

// Describes the destination Amazon Simple Storage Service (Amazon S3) bucket name
// and object keys of a recommendations export file, and its associated metadata
// file.
type S3Destination struct {

	// The name of the Amazon S3 bucket used as the destination of an export file.
	Bucket *string

	// The Amazon S3 bucket key of an export file.
	//
	// The key uniquely identifies the object, or export file, in the S3 bucket.
	Key *string

	// The Amazon S3 bucket key of a metadata file.
	//
	// The key uniquely identifies the object, or metadata file, in the S3 bucket.
	MetadataKey *string

	noSmithyDocumentSerde
}

func (v *S3Destination) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.S3Destination)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *S3Destination) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Bucket != nil {
		s.WriteString(schemas.S3Destination_bucket, *v.Bucket)
	}
	if v.Key != nil {
		s.WriteString(schemas.S3Destination_key, *v.Key)
	}
	if v.MetadataKey != nil {
		s.WriteString(schemas.S3Destination_metadataKey, *v.MetadataKey)
	}
}
func (v *S3Destination) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.S3Destination, func(s *smithy.Schema) error {
		switch s {
		case schemas.S3Destination_bucket:
			v.Bucket = new(string)
			return d.ReadString(schemas.S3Destination_bucket, v.Bucket)
		case schemas.S3Destination_key:
			v.Key = new(string)
			return d.ReadString(schemas.S3Destination_key, v.Key)
		case schemas.S3Destination_metadataKey:
			v.MetadataKey = new(string)
			return d.ReadString(schemas.S3Destination_metadataKey, v.MetadataKey)
		}
		return nil
	})
}

// Describes the destination Amazon Simple Storage Service (Amazon S3) bucket name
// and key prefix for a recommendations export job.
//
// You must create the destination Amazon S3 bucket for your recommendations
// export before you create the export job. Compute Optimizer does not create the
// S3 bucket for you. After you create the S3 bucket, ensure that it has the
// required permission policy to allow Compute Optimizer to write the export file
// to it. If you plan to specify an object prefix when you create the export job,
// you must include the object prefix in the policy that you add to the S3 bucket.
// For more information, see [Amazon S3 Bucket Policy for Compute Optimizer]in the Compute Optimizer User Guide.
//
// [Amazon S3 Bucket Policy for Compute Optimizer]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/create-s3-bucket-policy-for-compute-optimizer.html
type S3DestinationConfig struct {

	// The name of the Amazon S3 bucket to use as the destination for an export job.
	Bucket *string

	// The Amazon S3 bucket prefix for an export job.
	KeyPrefix *string

	noSmithyDocumentSerde
}

func (v *S3DestinationConfig) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.S3DestinationConfig)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *S3DestinationConfig) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Bucket != nil {
		s.WriteString(schemas.S3DestinationConfig_bucket, *v.Bucket)
	}
	if v.KeyPrefix != nil {
		s.WriteString(schemas.S3DestinationConfig_keyPrefix, *v.KeyPrefix)
	}
}
func (v *S3DestinationConfig) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.S3DestinationConfig, func(s *smithy.Schema) error {
		switch s {
		case schemas.S3DestinationConfig_bucket:
			v.Bucket = new(string)
			return d.ReadString(schemas.S3DestinationConfig_bucket, v.Bucket)
		case schemas.S3DestinationConfig_keyPrefix:
			v.KeyPrefix = new(string)
			return d.ReadString(schemas.S3DestinationConfig_keyPrefix, v.KeyPrefix)
		}
		return nil
	})
}

// Describes the savings opportunity for recommendations of a given resource type
// or for the recommendation option of an individual resource.
//
// Savings opportunity represents the estimated monthly savings you can achieve by
// implementing a given Compute Optimizer recommendation.
//
// Savings opportunity data requires that you opt in to Cost Explorer, as well as
// activate Receive Amazon EC2 resource recommendations in the Cost Explorer
// preferences page. That creates a connection between Cost Explorer and Compute
// Optimizer. With this connection, Cost Explorer generates savings estimates
// considering the price of existing resources, the price of recommended resources,
// and historical usage data. Estimated monthly savings reflects the projected
// dollar savings associated with each of the recommendations generated. For more
// information, see [Enabling Cost Explorer]and [Optimizing your cost with Rightsizing Recommendations] in the Cost Management User Guide.
//
// [Optimizing your cost with Rightsizing Recommendations]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-rightsizing.html
// [Enabling Cost Explorer]: https://docs.aws.amazon.com/cost-management/latest/userguide/ce-enable.html
type SavingsOpportunity struct {

	// An object that describes the estimated monthly savings amount possible by
	// adopting Compute Optimizer recommendations for a given resource. This is based
	// on the On-Demand instance pricing..
	EstimatedMonthlySavings *EstimatedMonthlySavings

	// The estimated monthly savings possible as a percentage of monthly cost by
	// adopting Compute Optimizer recommendations for a given resource.
	SavingsOpportunityPercentage float64

	noSmithyDocumentSerde
}

func (v *SavingsOpportunity) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.SavingsOpportunity)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *SavingsOpportunity) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EstimatedMonthlySavings != nil {
		s.WriteStruct(schemas.SavingsOpportunity_estimatedMonthlySavings)
		v.EstimatedMonthlySavings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityPercentage != 0 {
		s.WriteFloat64(schemas.SavingsOpportunity_savingsOpportunityPercentage, v.SavingsOpportunityPercentage)
	}
}
func (v *SavingsOpportunity) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.SavingsOpportunity, func(s *smithy.Schema) error {
		switch s {
		case schemas.SavingsOpportunity_estimatedMonthlySavings:
			v.EstimatedMonthlySavings = &EstimatedMonthlySavings{}
			return v.EstimatedMonthlySavings.Deserialize(d)
		case schemas.SavingsOpportunity_savingsOpportunityPercentage:
			return d.ReadFloat64(schemas.SavingsOpportunity_savingsOpportunityPercentage, &v.SavingsOpportunityPercentage)
		}
		return nil
	})
}

// Describes the scope of a recommendation preference.
//
// Recommendation preferences can be created at the organization level (for
// management accounts of an organization only), account level, and resource level.
// For more information, see [Activating enhanced infrastructure metrics]in the Compute Optimizer User Guide.
//
// You cannot create recommendation preferences for Auto Scaling groups at the
// organization and account levels. You can create recommendation preferences for
// Auto Scaling groups only at the resource level by specifying a scope name of
// ResourceArn and a scope value of the Auto Scaling group Amazon Resource Name
// (ARN). This will configure the preference for all instances that are part of the
// specified Auto Scaling group. You also cannot create recommendation preferences
// at the resource level for instances that are part of an Auto Scaling group. You
// can create recommendation preferences at the resource level only for standalone
// instances.
//
// [Activating enhanced infrastructure metrics]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/enhanced-infrastructure-metrics.html
type Scope struct {

	// The name of the scope.
	//
	// The following scopes are possible:
	//
	//   - Organization - Specifies that the recommendation preference applies at the
	//   organization level, for all member accounts of an organization.
	//
	//   - AccountId - Specifies that the recommendation preference applies at the
	//   account level, for all resources of a given resource type in an account.
	//
	//   - ResourceArn - Specifies that the recommendation preference applies at the
	//   individual resource level.
	Name ScopeName

	// The value of the scope.
	//
	// If you specified the name of the scope as:
	//
	//   - Organization - The value must be ALL_ACCOUNTS .
	//
	//   - AccountId - The value must be a 12-digit Amazon Web Services account ID.
	//
	//   - ResourceArn - The value must be the Amazon Resource Name (ARN) of an EC2
	//   instance or an Auto Scaling group.
	//
	// Only EC2 instance and Auto Scaling group ARNs are currently supported.
	Value *string

	noSmithyDocumentSerde
}

func (v *Scope) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.Scope)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *Scope) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.Scope_name, string(v.Name))
	}
	if v.Value != nil {
		s.WriteString(schemas.Scope_value, *v.Value)
	}
}
func (v *Scope) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Scope, func(s *smithy.Schema) error {
		switch s {
		case schemas.Scope_name:
			var ev string
			if err := d.ReadString(schemas.Scope_name, &ev); err != nil {
				return err
			}
			v.Name = ScopeName(ev)
			return nil
		case schemas.Scope_value:
			v.Value = new(string)
			return d.ReadString(schemas.Scope_value, v.Value)
		}
		return nil
	})
}

// The Amazon ECS service configurations used for recommendations.
type ServiceConfiguration struct {

	//  Describes the Auto Scaling configuration methods for an Amazon ECS service.
	// This affects the generated recommendations. For example, if Auto Scaling is
	// configured on a service’s CPU, then Compute Optimizer doesn’t generate CPU size
	// recommendations.
	//
	// The Auto Scaling configuration methods include:
	//
	//   - TARGET_TRACKING_SCALING_CPU — If the Amazon ECS service is configured to use
	//   target scaling on CPU, Compute Optimizer doesn't generate CPU recommendations.
	//
	//   - TARGET_TRACKING_SCALING_MEMORY — If the Amazon ECS service is configured to
	//   use target scaling on memory, Compute Optimizer doesn't generate memory
	//   recommendations.
	//
	// For more information about step scaling and target scaling, see [Step scaling policies for Application Auto Scaling] and [Target tracking scaling policies for Application Auto Scaling] in the
	// Application Auto Scaling User Guide.
	//
	// [Step scaling policies for Application Auto Scaling]: https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html
	// [Target tracking scaling policies for Application Auto Scaling]: https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html
	AutoScalingConfiguration AutoScalingConfiguration

	//  The container configurations within a task of an Amazon ECS service.
	ContainerConfigurations []ContainerConfiguration

	//  The number of CPU units used by the tasks in the Amazon ECS service.
	Cpu *int32

	//  The amount of memory used by the tasks in the Amazon ECS service.
	Memory *int32

	//  The task definition ARN used by the tasks in the Amazon ECS service.
	TaskDefinitionArn *string

	noSmithyDocumentSerde
}

func (v *ServiceConfiguration) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.ServiceConfiguration)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *ServiceConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AutoScalingConfiguration != "" {
		s.WriteString(schemas.ServiceConfiguration_autoScalingConfiguration, string(v.AutoScalingConfiguration))
	}
	serializeContainerConfigurations(s, schemas.ServiceConfiguration_containerConfigurations, v.ContainerConfigurations)
	if v.Cpu != nil {
		s.WriteInt32(schemas.ServiceConfiguration_cpu, *v.Cpu)
	}
	if v.Memory != nil {
		s.WriteInt32(schemas.ServiceConfiguration_memory, *v.Memory)
	}
	if v.TaskDefinitionArn != nil {
		s.WriteString(schemas.ServiceConfiguration_taskDefinitionArn, *v.TaskDefinitionArn)
	}
}
func (v *ServiceConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceConfiguration_autoScalingConfiguration:
			var ev string
			if err := d.ReadString(schemas.ServiceConfiguration_autoScalingConfiguration, &ev); err != nil {
				return err
			}
			v.AutoScalingConfiguration = AutoScalingConfiguration(ev)
			return nil
		case schemas.ServiceConfiguration_containerConfigurations:
			return deserializeContainerConfigurations(d, schemas.ServiceConfiguration_containerConfigurations, &v.ContainerConfigurations)
		case schemas.ServiceConfiguration_cpu:
			v.Cpu = new(int32)
			return d.ReadInt32(schemas.ServiceConfiguration_cpu, v.Cpu)
		case schemas.ServiceConfiguration_memory:
			v.Memory = new(int32)
			return d.ReadInt32(schemas.ServiceConfiguration_memory, v.Memory)
		case schemas.ServiceConfiguration_taskDefinitionArn:
			v.TaskDefinitionArn = new(string)
			return d.ReadString(schemas.ServiceConfiguration_taskDefinitionArn, v.TaskDefinitionArn)
		}
		return nil
	})
}

// The summary of a recommendation.
type Summary struct {

	// The finding classification of the recommendation.
	Name Finding

	// An array of objects that summarize a finding reason code.
	ReasonCodeSummaries []ReasonCodeSummary

	// The value of the recommendation summary.
	Value float64

	noSmithyDocumentSerde
}

func (v *Summary) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.Summary)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *Summary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.Summary_name, string(v.Name))
	}
	serializeReasonCodeSummaries(s, schemas.Summary_reasonCodeSummaries, v.ReasonCodeSummaries)
	if v.Value != 0 {
		s.WriteFloat64(schemas.Summary_value, v.Value)
	}
}
func (v *Summary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Summary, func(s *smithy.Schema) error {
		switch s {
		case schemas.Summary_name:
			var ev string
			if err := d.ReadString(schemas.Summary_name, &ev); err != nil {
				return err
			}
			v.Name = Finding(ev)
			return nil
		case schemas.Summary_reasonCodeSummaries:
			return deserializeReasonCodeSummaries(d, schemas.Summary_reasonCodeSummaries, &v.ReasonCodeSummaries)
		case schemas.Summary_value:
			return d.ReadFloat64(schemas.Summary_value, &v.Value)
		}
		return nil
	})
}

// A list of tag key and value pairs that you define.
type Tag struct {

	//  One part of a key-value pair that makes up a tag. A key is a general label
	// that acts like a category for more specific tag values.
	Key *string

	//  One part of a key-value pair that make up a tag. A value acts as a descriptor
	// within a tag category (key). The value can be empty or null.
	Value *string

	noSmithyDocumentSerde
}

func (v *Tag) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.Tag)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *Tag) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Key != nil {
		s.WriteString(schemas.Tag_key, *v.Key)
	}
	if v.Value != nil {
		s.WriteString(schemas.Tag_value, *v.Value)
	}
}
func (v *Tag) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Tag, func(s *smithy.Schema) error {
		switch s {
		case schemas.Tag_key:
			v.Key = new(string)
			return d.ReadString(schemas.Tag_key, v.Key)
		case schemas.Tag_value:
			v.Value = new(string)
			return d.ReadString(schemas.Tag_value, v.Value)
		}
		return nil
	})
}

// Describes a utilization metric of a resource, such as an Amazon EC2 instance.
//
// Compare the utilization metric data of your resource against its projected
// utilization metric data to determine the performance difference between your
// current resource and the recommended option.
type UtilizationMetric struct {

	// The name of the utilization metric.
	//
	// The following utilization metrics are available:
	//
	//   - Cpu - The percentage of allocated EC2 compute units that are currently in
	//   use on the instance. This metric identifies the processing power required to run
	//   an application on the instance.
	//
	// Depending on the instance type, tools in your operating system can show a lower
	//   percentage than CloudWatch when the instance is not allocated a full processor
	//   core.
	//
	// Units: Percent
	//
	//   - Memory - The percentage of memory that is currently in use on the instance.
	//   This metric identifies the amount of memory required to run an application on
	//   the instance.
	//
	// Units: Percent
	//
	// The Memory metric is returned only for resources that have the unified
	//   CloudWatch agent installed on them. For more information, see [Enabling Memory Utilization with the CloudWatch Agent].
	//
	//   - GPU - The percentage of allocated GPUs that currently run on the instance.
	//
	//   - GPU_MEMORY - The percentage of total GPU memory that currently runs on the
	//   instance.
	//
	// The GPU and GPU_MEMORY metrics are only returned for resources with the unified
	//   CloudWatch Agent installed on them. For more information, see [Enabling NVIDIA GPU utilization with the CloudWatch Agent].
	//
	//   - EBS_READ_OPS_PER_SECOND - The completed read operations from all EBS volumes
	//   attached to the instance in a specified period of time.
	//
	// Unit: Count
	//
	//   - EBS_WRITE_OPS_PER_SECOND - The completed write operations to all EBS volumes
	//   attached to the instance in a specified period of time.
	//
	// Unit: Count
	//
	//   - EBS_READ_BYTES_PER_SECOND - The bytes read from all EBS volumes attached to
	//   the instance in a specified period of time.
	//
	// Unit: Bytes
	//
	//   - EBS_WRITE_BYTES_PER_SECOND - The bytes written to all EBS volumes attached
	//   to the instance in a specified period of time.
	//
	// Unit: Bytes
	//
	//   - DISK_READ_OPS_PER_SECOND - The completed read operations from all instance
	//   store volumes available to the instance in a specified period of time.
	//
	// If there are no instance store volumes, either the value is 0 or the metric is
	//   not reported.
	//
	//   - DISK_WRITE_OPS_PER_SECOND - The completed write operations from all instance
	//   store volumes available to the instance in a specified period of time.
	//
	// If there are no instance store volumes, either the value is 0 or the metric is
	//   not reported.
	//
	//   - DISK_READ_BYTES_PER_SECOND - The bytes read from all instance store volumes
	//   available to the instance. This metric is used to determine the volume of the
	//   data the application reads from the disk of the instance. This can be used to
	//   determine the speed of the application.
	//
	// If there are no instance store volumes, either the value is 0 or the metric is
	//   not reported.
	//
	//   - DISK_WRITE_BYTES_PER_SECOND - The bytes written to all instance store
	//   volumes available to the instance. This metric is used to determine the volume
	//   of the data the application writes onto the disk of the instance. This can be
	//   used to determine the speed of the application.
	//
	// If there are no instance store volumes, either the value is 0 or the metric is
	//   not reported.
	//
	//   - NETWORK_IN_BYTES_PER_SECOND - The number of bytes received by the instance
	//   on all network interfaces. This metric identifies the volume of incoming network
	//   traffic to a single instance.
	//
	//   - NETWORK_OUT_BYTES_PER_SECOND - The number of bytes sent out by the instance
	//   on all network interfaces. This metric identifies the volume of outgoing network
	//   traffic from a single instance.
	//
	//   - NETWORK_PACKETS_IN_PER_SECOND - The number of packets received by the
	//   instance on all network interfaces. This metric identifies the volume of
	//   incoming traffic in terms of the number of packets on a single instance.
	//
	//   - NETWORK_PACKETS_OUT_PER_SECOND - The number of packets sent out by the
	//   instance on all network interfaces. This metric identifies the volume of
	//   outgoing traffic in terms of the number of packets on a single instance.
	//
	// [Enabling Memory Utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#cw-agent
	// [Enabling NVIDIA GPU utilization with the CloudWatch Agent]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/metrics.html#nvidia-cw-agent
	Name MetricName

	// The statistic of the utilization metric.
	//
	// The Compute Optimizer API, Command Line Interface (CLI), and SDKs return
	// utilization metrics using only the Maximum statistic, which is the highest
	// value observed during the specified period.
	//
	// The Compute Optimizer console displays graphs for some utilization metrics
	// using the Average statistic, which is the value of Sum / SampleCount during the
	// specified period. For more information, see [Viewing resource recommendations]in the Compute Optimizer User
	// Guide. You can also get averaged utilization metric data for your resources
	// using Amazon CloudWatch. For more information, see the [Amazon CloudWatch User Guide].
	//
	// [Viewing resource recommendations]: https://docs.aws.amazon.com/compute-optimizer/latest/ug/viewing-recommendations.html
	// [Amazon CloudWatch User Guide]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html
	Statistic MetricStatistic

	// The value of the utilization metric.
	Value float64

	noSmithyDocumentSerde
}

func (v *UtilizationMetric) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.UtilizationMetric)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *UtilizationMetric) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != "" {
		s.WriteString(schemas.UtilizationMetric_name, string(v.Name))
	}
	if v.Statistic != "" {
		s.WriteString(schemas.UtilizationMetric_statistic, string(v.Statistic))
	}
	if v.Value != 0 {
		s.WriteFloat64(schemas.UtilizationMetric_value, v.Value)
	}
}
func (v *UtilizationMetric) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.UtilizationMetric, func(s *smithy.Schema) error {
		switch s {
		case schemas.UtilizationMetric_name:
			var ev string
			if err := d.ReadString(schemas.UtilizationMetric_name, &ev); err != nil {
				return err
			}
			v.Name = MetricName(ev)
			return nil
		case schemas.UtilizationMetric_statistic:
			var ev string
			if err := d.ReadString(schemas.UtilizationMetric_statistic, &ev); err != nil {
				return err
			}
			v.Statistic = MetricStatistic(ev)
			return nil
		case schemas.UtilizationMetric_value:
			return d.ReadFloat64(schemas.UtilizationMetric_value, &v.Value)
		}
		return nil
	})
}

//	The preference to control the resource’s CPU utilization threshold, CPU
//
// utilization headroom, and memory utilization headroom.
//
// This preference is only available for the Amazon EC2 instance resource type.
type UtilizationPreference struct {

	//  The name of the resource utilization metric name to customize.
	MetricName CustomizableMetricName

	//  The parameters to set when customizing the resource utilization thresholds.
	MetricParameters *CustomizableMetricParameters

	noSmithyDocumentSerde
}

func (v *UtilizationPreference) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.UtilizationPreference)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *UtilizationPreference) SerializeMembers(s smithy.ShapeSerializer) {
	if v.MetricName != "" {
		s.WriteString(schemas.UtilizationPreference_metricName, string(v.MetricName))
	}
	if v.MetricParameters != nil {
		s.WriteStruct(schemas.UtilizationPreference_metricParameters)
		v.MetricParameters.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *UtilizationPreference) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.UtilizationPreference, func(s *smithy.Schema) error {
		switch s {
		case schemas.UtilizationPreference_metricName:
			var ev string
			if err := d.ReadString(schemas.UtilizationPreference_metricName, &ev); err != nil {
				return err
			}
			v.MetricName = CustomizableMetricName(ev)
			return nil
		case schemas.UtilizationPreference_metricParameters:
			v.MetricParameters = &CustomizableMetricParameters{}
			return v.MetricParameters.Deserialize(d)
		}
		return nil
	})
}

// Describes the configuration of an Amazon Elastic Block Store (Amazon EBS)
// volume.
type VolumeConfiguration struct {

	//  Contains the image used to boot the instance during launch.
	RootVolume *bool

	// The baseline IOPS of the volume.
	VolumeBaselineIOPS int32

	// The baseline throughput of the volume.
	VolumeBaselineThroughput int32

	// The burst IOPS of the volume.
	VolumeBurstIOPS int32

	// The burst throughput of the volume.
	VolumeBurstThroughput int32

	// The size of the volume, in GiB.
	VolumeSize int32

	// The volume type.
	//
	// The volume types can be the following:
	//
	//   - General Purpose SSD gp2 and gp3
	//
	//   - Provisioned IOPS SSD io1 , io2 , and io2 Block Express
	//
	//   - Throughput Optimized HDD st1
	//
	//   - Cold HDD sc1
	//
	//   - Magnetic volumes standard
	VolumeType *string

	noSmithyDocumentSerde
}

func (v *VolumeConfiguration) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.VolumeConfiguration)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *VolumeConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.RootVolume != nil {
		s.WriteBool(schemas.VolumeConfiguration_rootVolume, *v.RootVolume)
	}
	if v.VolumeBaselineIOPS != 0 {
		s.WriteInt32(schemas.VolumeConfiguration_volumeBaselineIOPS, v.VolumeBaselineIOPS)
	}
	if v.VolumeBaselineThroughput != 0 {
		s.WriteInt32(schemas.VolumeConfiguration_volumeBaselineThroughput, v.VolumeBaselineThroughput)
	}
	if v.VolumeBurstIOPS != 0 {
		s.WriteInt32(schemas.VolumeConfiguration_volumeBurstIOPS, v.VolumeBurstIOPS)
	}
	if v.VolumeBurstThroughput != 0 {
		s.WriteInt32(schemas.VolumeConfiguration_volumeBurstThroughput, v.VolumeBurstThroughput)
	}
	if v.VolumeSize != 0 {
		s.WriteInt32(schemas.VolumeConfiguration_volumeSize, v.VolumeSize)
	}
	if v.VolumeType != nil {
		s.WriteString(schemas.VolumeConfiguration_volumeType, *v.VolumeType)
	}
}
func (v *VolumeConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.VolumeConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.VolumeConfiguration_rootVolume:
			v.RootVolume = new(bool)
			return d.ReadBool(schemas.VolumeConfiguration_rootVolume, v.RootVolume)
		case schemas.VolumeConfiguration_volumeBaselineIOPS:
			return d.ReadInt32(schemas.VolumeConfiguration_volumeBaselineIOPS, &v.VolumeBaselineIOPS)
		case schemas.VolumeConfiguration_volumeBaselineThroughput:
			return d.ReadInt32(schemas.VolumeConfiguration_volumeBaselineThroughput, &v.VolumeBaselineThroughput)
		case schemas.VolumeConfiguration_volumeBurstIOPS:
			return d.ReadInt32(schemas.VolumeConfiguration_volumeBurstIOPS, &v.VolumeBurstIOPS)
		case schemas.VolumeConfiguration_volumeBurstThroughput:
			return d.ReadInt32(schemas.VolumeConfiguration_volumeBurstThroughput, &v.VolumeBurstThroughput)
		case schemas.VolumeConfiguration_volumeSize:
			return d.ReadInt32(schemas.VolumeConfiguration_volumeSize, &v.VolumeSize)
		case schemas.VolumeConfiguration_volumeType:
			v.VolumeType = new(string)
			return d.ReadString(schemas.VolumeConfiguration_volumeType, v.VolumeType)
		}
		return nil
	})
}

// Describes an Amazon Elastic Block Store (Amazon EBS) volume recommendation.
type VolumeRecommendation struct {

	// The Amazon Web Services account ID of the volume.
	AccountId *string

	// An array of objects that describe the current configuration of the volume.
	CurrentConfiguration *VolumeConfiguration

	// The risk of the current EBS volume not meeting the performance needs of its
	// workloads. The higher the risk, the more likely the current EBS volume doesn't
	// have sufficient capacity.
	CurrentPerformanceRisk CurrentPerformanceRisk

	//  Describes the effective recommendation preferences for Amazon EBS volume.
	EffectiveRecommendationPreferences *EBSEffectiveRecommendationPreferences

	// The finding classification of the volume.
	//
	// Findings for volumes include:
	//
	//   - NotOptimized —A volume is considered not optimized when Compute Optimizer
	//   identifies a recommendation that can provide better performance for your
	//   workload.
	//
	//   - Optimized —An volume is considered optimized when Compute Optimizer
	//   determines that the volume is correctly provisioned to run your workload based
	//   on the chosen volume type. For optimized resources, Compute Optimizer might
	//   recommend a new generation volume type.
	Finding EBSFinding

	// The timestamp of when the volume recommendation was last generated.
	LastRefreshTimestamp *time.Time

	// The number of days for which utilization metrics were analyzed for the volume.
	LookBackPeriodInDays float64

	//  A list of tags assigned to your Amazon EBS volume recommendations.
	Tags []Tag

	// An array of objects that describe the utilization metrics of the volume.
	UtilizationMetrics []EBSUtilizationMetric

	// The Amazon Resource Name (ARN) of the current volume.
	VolumeArn *string

	// An array of objects that describe the recommendation options for the volume.
	VolumeRecommendationOptions []VolumeRecommendationOption

	noSmithyDocumentSerde
}

func (v *VolumeRecommendation) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.VolumeRecommendation)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *VolumeRecommendation) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccountId != nil {
		s.WriteString(schemas.VolumeRecommendation_accountId, *v.AccountId)
	}
	if v.CurrentConfiguration != nil {
		s.WriteStruct(schemas.VolumeRecommendation_currentConfiguration)
		v.CurrentConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CurrentPerformanceRisk != "" {
		s.WriteString(schemas.VolumeRecommendation_currentPerformanceRisk, string(v.CurrentPerformanceRisk))
	}
	if v.EffectiveRecommendationPreferences != nil {
		s.WriteStruct(schemas.VolumeRecommendation_effectiveRecommendationPreferences)
		v.EffectiveRecommendationPreferences.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Finding != "" {
		s.WriteString(schemas.VolumeRecommendation_finding, string(v.Finding))
	}
	if v.LastRefreshTimestamp != nil {
		s.WriteTime(schemas.VolumeRecommendation_lastRefreshTimestamp, *v.LastRefreshTimestamp)
	}
	if v.LookBackPeriodInDays != 0 {
		s.WriteFloat64(schemas.VolumeRecommendation_lookBackPeriodInDays, v.LookBackPeriodInDays)
	}
	serializeTags(s, schemas.VolumeRecommendation_tags, v.Tags)
	serializeEBSUtilizationMetrics(s, schemas.VolumeRecommendation_utilizationMetrics, v.UtilizationMetrics)
	if v.VolumeArn != nil {
		s.WriteString(schemas.VolumeRecommendation_volumeArn, *v.VolumeArn)
	}
	serializeVolumeRecommendationOptions(s, schemas.VolumeRecommendation_volumeRecommendationOptions, v.VolumeRecommendationOptions)
}
func (v *VolumeRecommendation) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.VolumeRecommendation, func(s *smithy.Schema) error {
		switch s {
		case schemas.VolumeRecommendation_accountId:
			v.AccountId = new(string)
			return d.ReadString(schemas.VolumeRecommendation_accountId, v.AccountId)
		case schemas.VolumeRecommendation_currentConfiguration:
			v.CurrentConfiguration = &VolumeConfiguration{}
			return v.CurrentConfiguration.Deserialize(d)
		case schemas.VolumeRecommendation_currentPerformanceRisk:
			var ev string
			if err := d.ReadString(schemas.VolumeRecommendation_currentPerformanceRisk, &ev); err != nil {
				return err
			}
			v.CurrentPerformanceRisk = CurrentPerformanceRisk(ev)
			return nil
		case schemas.VolumeRecommendation_effectiveRecommendationPreferences:
			v.EffectiveRecommendationPreferences = &EBSEffectiveRecommendationPreferences{}
			return v.EffectiveRecommendationPreferences.Deserialize(d)
		case schemas.VolumeRecommendation_finding:
			var ev string
			if err := d.ReadString(schemas.VolumeRecommendation_finding, &ev); err != nil {
				return err
			}
			v.Finding = EBSFinding(ev)
			return nil
		case schemas.VolumeRecommendation_lastRefreshTimestamp:
			v.LastRefreshTimestamp = new(time.Time)
			return d.ReadTime(schemas.VolumeRecommendation_lastRefreshTimestamp, v.LastRefreshTimestamp)
		case schemas.VolumeRecommendation_lookBackPeriodInDays:
			return d.ReadFloat64(schemas.VolumeRecommendation_lookBackPeriodInDays, &v.LookBackPeriodInDays)
		case schemas.VolumeRecommendation_tags:
			return deserializeTags(d, schemas.VolumeRecommendation_tags, &v.Tags)
		case schemas.VolumeRecommendation_utilizationMetrics:
			return deserializeEBSUtilizationMetrics(d, schemas.VolumeRecommendation_utilizationMetrics, &v.UtilizationMetrics)
		case schemas.VolumeRecommendation_volumeArn:
			v.VolumeArn = new(string)
			return d.ReadString(schemas.VolumeRecommendation_volumeArn, v.VolumeArn)
		case schemas.VolumeRecommendation_volumeRecommendationOptions:
			return deserializeVolumeRecommendationOptions(d, schemas.VolumeRecommendation_volumeRecommendationOptions, &v.VolumeRecommendationOptions)
		}
		return nil
	})
}

// Describes a recommendation option for an Amazon Elastic Block Store (Amazon
// EBS) instance.
type VolumeRecommendationOption struct {

	// An array of objects that describe a volume configuration.
	Configuration *VolumeConfiguration

	// The performance risk of the volume recommendation option.
	//
	// Performance risk is the likelihood of the recommended volume type meeting the
	// performance requirement of your workload.
	//
	// The value ranges from 0 - 4 , with 0 meaning that the recommended resource is
	// predicted to always provide enough hardware capability. The higher the
	// performance risk is, the more likely you should validate whether the
	// recommendation will meet the performance requirements of your workload before
	// migrating your resource.
	PerformanceRisk float64

	// The rank of the volume recommendation option.
	//
	// The top recommendation option is ranked as 1 .
	Rank int32

	// An object that describes the savings opportunity for the EBS volume
	// recommendation option. Savings opportunity includes the estimated monthly
	// savings amount and percentage.
	SavingsOpportunity *SavingsOpportunity

	//  An object that describes the savings opportunity for the Amazon EBS volume
	// recommendation option with specific discounts. Savings opportunity includes the
	// estimated monthly savings and percentage.
	SavingsOpportunityAfterDiscounts *EBSSavingsOpportunityAfterDiscounts

	noSmithyDocumentSerde
}

func (v *VolumeRecommendationOption) Serialize(s smithy.ShapeSerializer) {
	s.WriteStruct(schemas.VolumeRecommendationOption)
	v.SerializeMembers(s)
	s.CloseStruct()
}

func (v *VolumeRecommendationOption) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Configuration != nil {
		s.WriteStruct(schemas.VolumeRecommendationOption_configuration)
		v.Configuration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.PerformanceRisk != 0 {
		s.WriteFloat64(schemas.VolumeRecommendationOption_performanceRisk, v.PerformanceRisk)
	}
	if v.Rank != 0 {
		s.WriteInt32(schemas.VolumeRecommendationOption_rank, v.Rank)
	}
	if v.SavingsOpportunity != nil {
		s.WriteStruct(schemas.VolumeRecommendationOption_savingsOpportunity)
		v.SavingsOpportunity.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SavingsOpportunityAfterDiscounts != nil {
		s.WriteStruct(schemas.VolumeRecommendationOption_savingsOpportunityAfterDiscounts)
		v.SavingsOpportunityAfterDiscounts.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *VolumeRecommendationOption) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.VolumeRecommendationOption, func(s *smithy.Schema) error {
		switch s {
		case schemas.VolumeRecommendationOption_configuration:
			v.Configuration = &VolumeConfiguration{}
			return v.Configuration.Deserialize(d)
		case schemas.VolumeRecommendationOption_performanceRisk:
			return d.ReadFloat64(schemas.VolumeRecommendationOption_performanceRisk, &v.PerformanceRisk)
		case schemas.VolumeRecommendationOption_rank:
			return d.ReadInt32(schemas.VolumeRecommendationOption_rank, &v.Rank)
		case schemas.VolumeRecommendationOption_savingsOpportunity:
			v.SavingsOpportunity = &SavingsOpportunity{}
			return v.SavingsOpportunity.Deserialize(d)
		case schemas.VolumeRecommendationOption_savingsOpportunityAfterDiscounts:
			v.SavingsOpportunityAfterDiscounts = &EBSSavingsOpportunityAfterDiscounts{}
			return v.SavingsOpportunityAfterDiscounts.Deserialize(d)
		}
		return nil
	})
}

type noSmithyDocumentSerde = smithydocument.NoSerde
