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

package types

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

// An object that represents an Batch array job.
type ArrayProperties struct {

	// The size of the array job.
	Size *int32

	noSmithyDocumentSerde
}

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

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

// An object that represents the array properties of a job.
type ArrayPropertiesDetail struct {

	// The job index within the array that's associated with this job. This parameter
	// is returned for array job children.
	Index *int32

	// The size of the array job. This parameter is returned for parent array jobs.
	Size *int32

	// A summary of the number of array job children in each available job status.
	// This parameter is returned for parent array jobs.
	StatusSummary map[string]int32

	// The Unix timestamp (in milliseconds) for when the statusSummary was last
	// updated.
	StatusSummaryLastUpdatedAt *int64

	noSmithyDocumentSerde
}

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

func (v *ArrayPropertiesDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Index != nil {
		s.WriteInt32(schemas.ArrayPropertiesDetail_index, *v.Index)
	}
	if v.Size != nil {
		s.WriteInt32(schemas.ArrayPropertiesDetail_size, *v.Size)
	}
	if v.StatusSummary != nil {
		serializeArrayJobStatusSummary(s, schemas.ArrayPropertiesDetail_statusSummary, v.StatusSummary)
	}
	if v.StatusSummaryLastUpdatedAt != nil {
		s.WriteInt64(schemas.ArrayPropertiesDetail_statusSummaryLastUpdatedAt, *v.StatusSummaryLastUpdatedAt)
	}
}
func (v *ArrayPropertiesDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ArrayPropertiesDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.ArrayPropertiesDetail_index:
			v.Index = new(int32)
			return d.ReadInt32(schemas.ArrayPropertiesDetail_index, v.Index)
		case schemas.ArrayPropertiesDetail_size:
			v.Size = new(int32)
			return d.ReadInt32(schemas.ArrayPropertiesDetail_size, v.Size)
		case schemas.ArrayPropertiesDetail_statusSummary:
			return deserializeArrayJobStatusSummary(d, schemas.ArrayPropertiesDetail_statusSummary, &v.StatusSummary)
		case schemas.ArrayPropertiesDetail_statusSummaryLastUpdatedAt:
			v.StatusSummaryLastUpdatedAt = new(int64)
			return d.ReadInt64(schemas.ArrayPropertiesDetail_statusSummaryLastUpdatedAt, v.StatusSummaryLastUpdatedAt)
		}
		return nil
	})
}

// An object that represents the array properties of a job.
type ArrayPropertiesSummary struct {

	// The job index within the array that's associated with this job. This parameter
	// is returned for children of array jobs.
	Index *int32

	// The size of the array job. This parameter is returned for parent array jobs.
	Size *int32

	// A summary of the number of array job children in each available job status.
	// This parameter is returned for parent array jobs.
	StatusSummary map[string]int32

	// The Unix timestamp (in milliseconds) for when the statusSummary was last
	// updated.
	StatusSummaryLastUpdatedAt *int64

	noSmithyDocumentSerde
}

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

func (v *ArrayPropertiesSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Index != nil {
		s.WriteInt32(schemas.ArrayPropertiesSummary_index, *v.Index)
	}
	if v.Size != nil {
		s.WriteInt32(schemas.ArrayPropertiesSummary_size, *v.Size)
	}
	if v.StatusSummary != nil {
		serializeArrayJobStatusSummary(s, schemas.ArrayPropertiesSummary_statusSummary, v.StatusSummary)
	}
	if v.StatusSummaryLastUpdatedAt != nil {
		s.WriteInt64(schemas.ArrayPropertiesSummary_statusSummaryLastUpdatedAt, *v.StatusSummaryLastUpdatedAt)
	}
}
func (v *ArrayPropertiesSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ArrayPropertiesSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.ArrayPropertiesSummary_index:
			v.Index = new(int32)
			return d.ReadInt32(schemas.ArrayPropertiesSummary_index, v.Index)
		case schemas.ArrayPropertiesSummary_size:
			v.Size = new(int32)
			return d.ReadInt32(schemas.ArrayPropertiesSummary_size, v.Size)
		case schemas.ArrayPropertiesSummary_statusSummary:
			return deserializeArrayJobStatusSummary(d, schemas.ArrayPropertiesSummary_statusSummary, &v.StatusSummary)
		case schemas.ArrayPropertiesSummary_statusSummaryLastUpdatedAt:
			v.StatusSummaryLastUpdatedAt = new(int64)
			return d.ReadInt64(schemas.ArrayPropertiesSummary_statusSummaryLastUpdatedAt, v.StatusSummaryLastUpdatedAt)
		}
		return nil
	})
}

// An object that represents the details of a container that's part of a job
// attempt.
type AttemptContainerDetail struct {

	// The Amazon Resource Name (ARN) of the Amazon ECS container instance that hosts
	// the job attempt.
	ContainerInstanceArn *string

	// The exit code for the job attempt. A non-zero exit code is considered failed.
	ExitCode *int32

	// The name of the CloudWatch Logs log stream that's associated with the
	// container. The log group for Batch jobs is /aws/batch/job . Each container
	// attempt receives a log stream name when they reach the RUNNING status.
	LogStreamName *string

	// The network interfaces that are associated with the job attempt.
	NetworkInterfaces []NetworkInterface

	// A short (255 max characters) human-readable string to provide additional
	// details for a running or stopped container.
	Reason *string

	// The Amazon Resource Name (ARN) of the Amazon ECS task that's associated with
	// the job attempt. Each container attempt receives a task ARN when they reach the
	// STARTING status.
	TaskArn *string

	noSmithyDocumentSerde
}

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

func (v *AttemptContainerDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerInstanceArn != nil {
		s.WriteString(schemas.AttemptContainerDetail_containerInstanceArn, *v.ContainerInstanceArn)
	}
	if v.ExitCode != nil {
		s.WriteInt32(schemas.AttemptContainerDetail_exitCode, *v.ExitCode)
	}
	if v.LogStreamName != nil {
		s.WriteString(schemas.AttemptContainerDetail_logStreamName, *v.LogStreamName)
	}
	if v.NetworkInterfaces != nil {
		serializeNetworkInterfaceList(s, schemas.AttemptContainerDetail_networkInterfaces, v.NetworkInterfaces)
	}
	if v.Reason != nil {
		s.WriteString(schemas.AttemptContainerDetail_reason, *v.Reason)
	}
	if v.TaskArn != nil {
		s.WriteString(schemas.AttemptContainerDetail_taskArn, *v.TaskArn)
	}
}
func (v *AttemptContainerDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AttemptContainerDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.AttemptContainerDetail_containerInstanceArn:
			v.ContainerInstanceArn = new(string)
			return d.ReadString(schemas.AttemptContainerDetail_containerInstanceArn, v.ContainerInstanceArn)
		case schemas.AttemptContainerDetail_exitCode:
			v.ExitCode = new(int32)
			return d.ReadInt32(schemas.AttemptContainerDetail_exitCode, v.ExitCode)
		case schemas.AttemptContainerDetail_logStreamName:
			v.LogStreamName = new(string)
			return d.ReadString(schemas.AttemptContainerDetail_logStreamName, v.LogStreamName)
		case schemas.AttemptContainerDetail_networkInterfaces:
			return deserializeNetworkInterfaceList(d, schemas.AttemptContainerDetail_networkInterfaces, &v.NetworkInterfaces)
		case schemas.AttemptContainerDetail_reason:
			v.Reason = new(string)
			return d.ReadString(schemas.AttemptContainerDetail_reason, v.Reason)
		case schemas.AttemptContainerDetail_taskArn:
			v.TaskArn = new(string)
			return d.ReadString(schemas.AttemptContainerDetail_taskArn, v.TaskArn)
		}
		return nil
	})
}

// An object that represents a job attempt.
type AttemptDetail struct {

	// The details for the container in this job attempt.
	Container *AttemptContainerDetail

	// The Unix timestamp (in milliseconds) for when the attempt was started (when the
	// attempt transitioned from the STARTING state to the RUNNING state).
	StartedAt *int64

	// A short, human-readable string to provide additional details for the current
	// status of the job attempt.
	StatusReason *string

	// The Unix timestamp (in milliseconds) for when the attempt was stopped (when the
	// attempt transitioned from the RUNNING state to a terminal state, such as
	// SUCCEEDED or FAILED ).
	StoppedAt *int64

	// The properties for a task definition that describes the container and volume
	// definitions of an Amazon ECS task.
	TaskProperties []AttemptEcsTaskDetails

	noSmithyDocumentSerde
}

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

func (v *AttemptDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Container != nil {
		s.WriteStruct(schemas.AttemptDetail_container)
		v.Container.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.StartedAt != nil {
		s.WriteInt64(schemas.AttemptDetail_startedAt, *v.StartedAt)
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.AttemptDetail_statusReason, *v.StatusReason)
	}
	if v.StoppedAt != nil {
		s.WriteInt64(schemas.AttemptDetail_stoppedAt, *v.StoppedAt)
	}
	if v.TaskProperties != nil {
		serializeListAttemptEcsTaskDetails(s, schemas.AttemptDetail_taskProperties, v.TaskProperties)
	}
}
func (v *AttemptDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AttemptDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.AttemptDetail_container:
			v.Container = &AttemptContainerDetail{}
			return v.Container.Deserialize(d)
		case schemas.AttemptDetail_startedAt:
			v.StartedAt = new(int64)
			return d.ReadInt64(schemas.AttemptDetail_startedAt, v.StartedAt)
		case schemas.AttemptDetail_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.AttemptDetail_statusReason, v.StatusReason)
		case schemas.AttemptDetail_stoppedAt:
			v.StoppedAt = new(int64)
			return d.ReadInt64(schemas.AttemptDetail_stoppedAt, v.StoppedAt)
		case schemas.AttemptDetail_taskProperties:
			return deserializeListAttemptEcsTaskDetails(d, schemas.AttemptDetail_taskProperties, &v.TaskProperties)
		}
		return nil
	})
}

// An object that represents the details of a task.
type AttemptEcsTaskDetails struct {

	// The Amazon Resource Name (ARN) of the container instance that hosts the task.
	ContainerInstanceArn *string

	// A list of containers that are included in the taskProperties list.
	Containers []AttemptTaskContainerDetails

	// The ARN of the Amazon ECS task.
	TaskArn *string

	noSmithyDocumentSerde
}

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

func (v *AttemptEcsTaskDetails) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerInstanceArn != nil {
		s.WriteString(schemas.AttemptEcsTaskDetails_containerInstanceArn, *v.ContainerInstanceArn)
	}
	if v.Containers != nil {
		serializeListAttemptTaskContainerDetails(s, schemas.AttemptEcsTaskDetails_containers, v.Containers)
	}
	if v.TaskArn != nil {
		s.WriteString(schemas.AttemptEcsTaskDetails_taskArn, *v.TaskArn)
	}
}
func (v *AttemptEcsTaskDetails) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AttemptEcsTaskDetails, func(s *smithy.Schema) error {
		switch s {
		case schemas.AttemptEcsTaskDetails_containerInstanceArn:
			v.ContainerInstanceArn = new(string)
			return d.ReadString(schemas.AttemptEcsTaskDetails_containerInstanceArn, v.ContainerInstanceArn)
		case schemas.AttemptEcsTaskDetails_containers:
			return deserializeListAttemptTaskContainerDetails(d, schemas.AttemptEcsTaskDetails_containers, &v.Containers)
		case schemas.AttemptEcsTaskDetails_taskArn:
			v.TaskArn = new(string)
			return d.ReadString(schemas.AttemptEcsTaskDetails_taskArn, v.TaskArn)
		}
		return nil
	})
}

// An object that represents the details of a container that's part of a job
// attempt.
type AttemptTaskContainerDetails struct {

	// The exit code for the container’s attempt. A non-zero exit code is considered
	// failed.
	ExitCode *int32

	// The name of the Amazon CloudWatch Logs log stream that's associated with the
	// container. The log group for Batch jobs is /aws/batch/job . Each container
	// attempt receives a log stream name when they reach the RUNNING status.
	LogStreamName *string

	// The name of a container.
	Name *string

	// The network interfaces that are associated with the job attempt.
	NetworkInterfaces []NetworkInterface

	// A short (255 max characters) string that's easy to understand and provides
	// additional details for a running or stopped container.
	Reason *string

	noSmithyDocumentSerde
}

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

func (v *AttemptTaskContainerDetails) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ExitCode != nil {
		s.WriteInt32(schemas.AttemptTaskContainerDetails_exitCode, *v.ExitCode)
	}
	if v.LogStreamName != nil {
		s.WriteString(schemas.AttemptTaskContainerDetails_logStreamName, *v.LogStreamName)
	}
	if v.Name != nil {
		s.WriteString(schemas.AttemptTaskContainerDetails_name, *v.Name)
	}
	if v.NetworkInterfaces != nil {
		serializeNetworkInterfaceList(s, schemas.AttemptTaskContainerDetails_networkInterfaces, v.NetworkInterfaces)
	}
	if v.Reason != nil {
		s.WriteString(schemas.AttemptTaskContainerDetails_reason, *v.Reason)
	}
}
func (v *AttemptTaskContainerDetails) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.AttemptTaskContainerDetails, func(s *smithy.Schema) error {
		switch s {
		case schemas.AttemptTaskContainerDetails_exitCode:
			v.ExitCode = new(int32)
			return d.ReadInt32(schemas.AttemptTaskContainerDetails_exitCode, v.ExitCode)
		case schemas.AttemptTaskContainerDetails_logStreamName:
			v.LogStreamName = new(string)
			return d.ReadString(schemas.AttemptTaskContainerDetails_logStreamName, v.LogStreamName)
		case schemas.AttemptTaskContainerDetails_name:
			v.Name = new(string)
			return d.ReadString(schemas.AttemptTaskContainerDetails_name, v.Name)
		case schemas.AttemptTaskContainerDetails_networkInterfaces:
			return deserializeNetworkInterfaceList(d, schemas.AttemptTaskContainerDetails_networkInterfaces, &v.NetworkInterfaces)
		case schemas.AttemptTaskContainerDetails_reason:
			v.Reason = new(string)
			return d.ReadString(schemas.AttemptTaskContainerDetails_reason, v.Reason)
		}
		return nil
	})
}

// An object that contains the details of a job that couldn't be cancelled by a
// CancelJobs operation.
type CancelJobsErrorDetail struct {

	// An error code that identifies the reason the job couldn't be cancelled. Valid
	// values are:
	//
	//   - ValidationException – A job identifier in the request is malformed or isn't
	//   valid.
	//
	//   - ClientException – The request failed because of a client error.
	//
	//   - ThrottlingException – The request was throttled. Retry the request.
	//
	//   - ServerException – An internal error occurred. Retry the request.
	//
	//   - AccessDenied – The caller isn't authorized to perform the action on the
	//   specified job.
	//
	// This member is required.
	Code *string

	// The Batch job ID of the job that couldn't be cancelled.
	//
	// This member is required.
	Job *string

	// A message that describes the reason the job couldn't be cancelled.
	//
	// This member is required.
	Message *string

	noSmithyDocumentSerde
}

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

func (v *CancelJobsErrorDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Code != nil {
		s.WriteString(schemas.CancelJobsErrorDetail_code, *v.Code)
	}
	if v.Job != nil {
		s.WriteString(schemas.CancelJobsErrorDetail_job, *v.Job)
	}
	if v.Message != nil {
		s.WriteString(schemas.CancelJobsErrorDetail_message, *v.Message)
	}
}
func (v *CancelJobsErrorDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.CancelJobsErrorDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.CancelJobsErrorDetail_code:
			v.Code = new(string)
			return d.ReadString(schemas.CancelJobsErrorDetail_code, v.Code)
		case schemas.CancelJobsErrorDetail_job:
			v.Job = new(string)
			return d.ReadString(schemas.CancelJobsErrorDetail_job, v.Job)
		case schemas.CancelJobsErrorDetail_message:
			v.Message = new(string)
			return d.ReadString(schemas.CancelJobsErrorDetail_message, v.Message)
		}
		return nil
	})
}

// Defines the type and maximum quantity of resources that can be allocated to
// service jobs in a service environment.
type CapacityLimit struct {

	// The unit of measure for the capacity limit, which defines how maxCapacity is
	// interpreted. For SAGEMAKER_TRAINING jobs in a quota management enabled service
	// environment, specify the [instance type](for example, ml.m5.large ). Otherwise, use
	// NUM_INSTANCES .
	//
	// [instance type]: https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ResourceConfig.html#sagemaker-Type-ResourceConfig-InstanceType
	CapacityUnit *string

	// The maximum capacity available for the service environment. For a quota
	// management enabled service environment, this value represents the maximum
	// quantity of a particular resource type (specified by capacityUnit ) that can be
	// allocated to service jobs. For other service environments, this value represents
	// the maximum quantity of all resources that can be allocated to service jobs.
	//
	// For example, if maxCapacity=50 and capacityUnit=NUM_INSTANCES , you can run up
	// to 50 instances concurrently. If you run 5 SageMaker Training jobs that each use
	// 10 instances, a subsequent job requiring 10 instances waits in the queue until
	// capacity is available. In a quota management enabled service environment with
	// capacityUnit=ml.m5.large , only ml.m5.large instances count against this limit,
	// and jobs requiring other instance types wait until a matching capacity limit is
	// configured.
	MaxCapacity *int32

	noSmithyDocumentSerde
}

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

func (v *CapacityLimit) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUnit != nil {
		s.WriteString(schemas.CapacityLimit_capacityUnit, *v.CapacityUnit)
	}
	if v.MaxCapacity != nil {
		s.WriteInt32(schemas.CapacityLimit_maxCapacity, *v.MaxCapacity)
	}
}
func (v *CapacityLimit) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.CapacityLimit, func(s *smithy.Schema) error {
		switch s {
		case schemas.CapacityLimit_capacityUnit:
			v.CapacityUnit = new(string)
			return d.ReadString(schemas.CapacityLimit_capacityUnit, v.CapacityUnit)
		case schemas.CapacityLimit_maxCapacity:
			v.MaxCapacity = new(int32)
			return d.ReadInt32(schemas.CapacityLimit_maxCapacity, v.MaxCapacity)
		}
		return nil
	})
}

// The capacity reservation configuration for Amazon ECS Managed Instances. Use
// this to target On-Demand Capacity Reservations or Reserved Instances.
type CapacityReservationRequest struct {

	// The Amazon Resource Name (ARN) of the capacity reservation group to target.
	ReservationGroupArn *string

	// The capacity reservation preference. Valid values:
	//
	//   - RESERVATIONS_ONLY — Use only capacity reservations.
	//
	//   - RESERVATIONS_FIRST — Prefer capacity reservations but fall back to On-Demand
	//   if unavailable.
	//
	//   - RESERVATIONS_EXCLUDED — Do not use capacity reservations.
	ReservationPreference *string

	noSmithyDocumentSerde
}

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

func (v *CapacityReservationRequest) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ReservationGroupArn != nil {
		s.WriteString(schemas.CapacityReservationRequest_reservationGroupArn, *v.ReservationGroupArn)
	}
	if v.ReservationPreference != nil {
		s.WriteString(schemas.CapacityReservationRequest_reservationPreference, *v.ReservationPreference)
	}
}
func (v *CapacityReservationRequest) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.CapacityReservationRequest, func(s *smithy.Schema) error {
		switch s {
		case schemas.CapacityReservationRequest_reservationGroupArn:
			v.ReservationGroupArn = new(string)
			return d.ReadString(schemas.CapacityReservationRequest_reservationGroupArn, v.ReservationGroupArn)
		case schemas.CapacityReservationRequest_reservationPreference:
			v.ReservationPreference = new(string)
			return d.ReadString(schemas.CapacityReservationRequest_reservationPreference, v.ReservationPreference)
		}
		return nil
	})
}

// An object that represents an Batch compute environment.
type ComputeEnvironmentDetail struct {

	// The Amazon Resource Name (ARN) of the compute environment.
	//
	// This member is required.
	ComputeEnvironmentArn *string

	// The name of the compute environment. It can be up to 128 characters long. It
	// can contain uppercase and lowercase letters, numbers, hyphens (-), and
	// underscores (_).
	//
	// This member is required.
	ComputeEnvironmentName *string

	// The compute resources defined for the compute environment. For more
	// information, see [Compute environments]in the Batch User Guide.
	//
	// [Compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html
	ComputeResources *ComputeResource

	// The orchestration type of the compute environment. The valid values are ECS
	// (default) or EKS .
	ContainerOrchestrationType OrchestrationType

	// Reserved.
	Context *string

	// The Amazon Resource Name (ARN) of the underlying Amazon ECS cluster that the
	// compute environment uses.
	EcsClusterArn *string

	// The Amazon ECS settings for the compute environment. These settings control
	// CloudWatch Container Insights collection.
	EcsSettings *EcsSettings

	// The configuration for the Amazon EKS cluster that supports the Batch compute
	// environment. Only specify this parameter if the containerOrchestrationType is
	// EKS .
	EksConfiguration *EksConfiguration

	// The service role that's associated with the compute environment that allows
	// Batch to make calls to Amazon Web Services API operations on your behalf. For
	// more information, see [Batch service IAM role]in the Batch User Guide.
	//
	// [Batch service IAM role]: https://docs.aws.amazon.com/batch/latest/userguide/service_IAM_role.html
	ServiceRole *string

	// The state of the compute environment. The valid values are ENABLED or DISABLED .
	//
	// If the state is ENABLED , then the Batch scheduler can attempt to place jobs
	// from an associated job queue on the compute resources within the environment. If
	// the compute environment is managed, then it can scale its instances out or in
	// automatically based on the job queue demand.
	//
	// If the state is DISABLED , then the Batch scheduler doesn't attempt to place
	// jobs within the environment. Jobs in a STARTING or RUNNING state continue to
	// progress normally. Managed compute environments in the DISABLED state don't
	// scale out.
	//
	// Compute environments in a DISABLED state may continue to incur billing charges,
	// for example, if they have running instances due to jobs that are still executing
	// or a non-zero minvCpus setting. To prevent additional charges, disable and
	// delete the compute environment.
	//
	// When an instance is idle, the instance scales down to the minvCpus value.
	// However, the instance size doesn't change. For example, consider a c5.8xlarge
	// instance with a minvCpus value of 4 and a desiredvCpus value of 36 . This
	// instance doesn't scale down to a c5.large instance.
	State CEState

	// The current status of the compute environment (for example, CREATING or VALID ).
	Status CEStatus

	// A short, human-readable string to provide additional details for the current
	// status of the compute environment.
	StatusReason *string

	// The tags applied to the compute environment.
	Tags map[string]string

	// The type of the compute environment: MANAGED or UNMANAGED . For more
	// information, see [Compute environments]in the Batch User Guide.
	//
	// [Compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html
	Type CEType

	// The maximum number of VCPUs expected to be used for an unmanaged compute
	// environment.
	UnmanagedvCpus *int32

	// Specifies the infrastructure update policy for the compute environment. For
	// more information about infrastructure updates, see [Updating compute environments]in the Batch User Guide.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	UpdatePolicy *UpdatePolicy

	// Unique identifier for the compute environment.
	Uuid *string

	noSmithyDocumentSerde
}

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

func (v *ComputeEnvironmentDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ComputeEnvironmentArn != nil {
		s.WriteString(schemas.ComputeEnvironmentDetail_computeEnvironmentArn, *v.ComputeEnvironmentArn)
	}
	if v.ComputeEnvironmentName != nil {
		s.WriteString(schemas.ComputeEnvironmentDetail_computeEnvironmentName, *v.ComputeEnvironmentName)
	}
	if v.ComputeResources != nil {
		s.WriteStruct(schemas.ComputeEnvironmentDetail_computeResources)
		v.ComputeResources.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ContainerOrchestrationType != "" {
		s.WriteString(schemas.ComputeEnvironmentDetail_containerOrchestrationType, string(v.ContainerOrchestrationType))
	}
	if v.Context != nil {
		s.WriteString(schemas.ComputeEnvironmentDetail_context, *v.Context)
	}
	if v.EcsClusterArn != nil {
		s.WriteString(schemas.ComputeEnvironmentDetail_ecsClusterArn, *v.EcsClusterArn)
	}
	if v.EcsSettings != nil {
		s.WriteStruct(schemas.ComputeEnvironmentDetail_ecsSettings)
		v.EcsSettings.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EksConfiguration != nil {
		s.WriteStruct(schemas.ComputeEnvironmentDetail_eksConfiguration)
		v.EksConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ServiceRole != nil {
		s.WriteString(schemas.ComputeEnvironmentDetail_serviceRole, *v.ServiceRole)
	}
	if v.State != "" {
		s.WriteString(schemas.ComputeEnvironmentDetail_state, string(v.State))
	}
	if v.Status != "" {
		s.WriteString(schemas.ComputeEnvironmentDetail_status, string(v.Status))
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.ComputeEnvironmentDetail_statusReason, *v.StatusReason)
	}
	if v.Tags != nil {
		serializeTagrisTagsMap(s, schemas.ComputeEnvironmentDetail_tags, v.Tags)
	}
	if v.Type != "" {
		s.WriteString(schemas.ComputeEnvironmentDetail_type, string(v.Type))
	}
	if v.UnmanagedvCpus != nil {
		s.WriteInt32(schemas.ComputeEnvironmentDetail_unmanagedvCpus, *v.UnmanagedvCpus)
	}
	if v.UpdatePolicy != nil {
		s.WriteStruct(schemas.ComputeEnvironmentDetail_updatePolicy)
		v.UpdatePolicy.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Uuid != nil {
		s.WriteString(schemas.ComputeEnvironmentDetail_uuid, *v.Uuid)
	}
}
func (v *ComputeEnvironmentDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ComputeEnvironmentDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.ComputeEnvironmentDetail_computeEnvironmentArn:
			v.ComputeEnvironmentArn = new(string)
			return d.ReadString(schemas.ComputeEnvironmentDetail_computeEnvironmentArn, v.ComputeEnvironmentArn)
		case schemas.ComputeEnvironmentDetail_computeEnvironmentName:
			v.ComputeEnvironmentName = new(string)
			return d.ReadString(schemas.ComputeEnvironmentDetail_computeEnvironmentName, v.ComputeEnvironmentName)
		case schemas.ComputeEnvironmentDetail_computeResources:
			v.ComputeResources = &ComputeResource{}
			return v.ComputeResources.Deserialize(d)
		case schemas.ComputeEnvironmentDetail_containerOrchestrationType:
			var ev string
			if err := d.ReadString(schemas.ComputeEnvironmentDetail_containerOrchestrationType, &ev); err != nil {
				return err
			}
			v.ContainerOrchestrationType = OrchestrationType(ev)
			return nil
		case schemas.ComputeEnvironmentDetail_context:
			v.Context = new(string)
			return d.ReadString(schemas.ComputeEnvironmentDetail_context, v.Context)
		case schemas.ComputeEnvironmentDetail_ecsClusterArn:
			v.EcsClusterArn = new(string)
			return d.ReadString(schemas.ComputeEnvironmentDetail_ecsClusterArn, v.EcsClusterArn)
		case schemas.ComputeEnvironmentDetail_ecsSettings:
			v.EcsSettings = &EcsSettings{}
			return v.EcsSettings.Deserialize(d)
		case schemas.ComputeEnvironmentDetail_eksConfiguration:
			v.EksConfiguration = &EksConfiguration{}
			return v.EksConfiguration.Deserialize(d)
		case schemas.ComputeEnvironmentDetail_serviceRole:
			v.ServiceRole = new(string)
			return d.ReadString(schemas.ComputeEnvironmentDetail_serviceRole, v.ServiceRole)
		case schemas.ComputeEnvironmentDetail_state:
			var ev string
			if err := d.ReadString(schemas.ComputeEnvironmentDetail_state, &ev); err != nil {
				return err
			}
			v.State = CEState(ev)
			return nil
		case schemas.ComputeEnvironmentDetail_status:
			var ev string
			if err := d.ReadString(schemas.ComputeEnvironmentDetail_status, &ev); err != nil {
				return err
			}
			v.Status = CEStatus(ev)
			return nil
		case schemas.ComputeEnvironmentDetail_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.ComputeEnvironmentDetail_statusReason, v.StatusReason)
		case schemas.ComputeEnvironmentDetail_tags:
			return deserializeTagrisTagsMap(d, schemas.ComputeEnvironmentDetail_tags, &v.Tags)
		case schemas.ComputeEnvironmentDetail_type:
			var ev string
			if err := d.ReadString(schemas.ComputeEnvironmentDetail_type, &ev); err != nil {
				return err
			}
			v.Type = CEType(ev)
			return nil
		case schemas.ComputeEnvironmentDetail_unmanagedvCpus:
			v.UnmanagedvCpus = new(int32)
			return d.ReadInt32(schemas.ComputeEnvironmentDetail_unmanagedvCpus, v.UnmanagedvCpus)
		case schemas.ComputeEnvironmentDetail_updatePolicy:
			v.UpdatePolicy = &UpdatePolicy{}
			return v.UpdatePolicy.Deserialize(d)
		case schemas.ComputeEnvironmentDetail_uuid:
			v.Uuid = new(string)
			return d.ReadString(schemas.ComputeEnvironmentDetail_uuid, v.Uuid)
		}
		return nil
	})
}

// The order that compute environments are tried in for job placement within a
// queue. Compute environments are tried in ascending order. For example, if two
// compute environments are associated with a job queue, the compute environment
// with a lower order integer value is tried for job placement first. Compute
// environments must be in the VALID state before you can associate them with a
// job queue. All of the compute environments must be either EC2 ( EC2 or SPOT ) or
// Fargate ( FARGATE or FARGATE_SPOT ); Amazon EC2 and Fargate compute environments
// can't be mixed.
//
// All compute environments that are associated with a job queue must share the
// same architecture. Batch doesn't support mixing compute environment architecture
// types in a single job queue.
type ComputeEnvironmentOrder struct {

	// The Amazon Resource Name (ARN) of the compute environment.
	//
	// This member is required.
	ComputeEnvironment *string

	// The order of the compute environment. Compute environments are tried in
	// ascending order. For example, if two compute environments are associated with a
	// job queue, the compute environment with a lower order integer value is tried
	// for job placement first.
	//
	// This member is required.
	Order *int32

	noSmithyDocumentSerde
}

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

func (v *ComputeEnvironmentOrder) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ComputeEnvironment != nil {
		s.WriteString(schemas.ComputeEnvironmentOrder_computeEnvironment, *v.ComputeEnvironment)
	}
	if v.Order != nil {
		s.WriteInt32(schemas.ComputeEnvironmentOrder_order, *v.Order)
	}
}
func (v *ComputeEnvironmentOrder) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ComputeEnvironmentOrder, func(s *smithy.Schema) error {
		switch s {
		case schemas.ComputeEnvironmentOrder_computeEnvironment:
			v.ComputeEnvironment = new(string)
			return d.ReadString(schemas.ComputeEnvironmentOrder_computeEnvironment, v.ComputeEnvironment)
		case schemas.ComputeEnvironmentOrder_order:
			v.Order = new(int32)
			return d.ReadInt32(schemas.ComputeEnvironmentOrder_order, v.Order)
		}
		return nil
	})
}

// An object that represents an Batch compute resource. For more information, see [Compute environments]
// in the Batch User Guide.
//
// [Compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html
type ComputeResource struct {

	// The maximum number of vCPUs that a compute environment can support.
	//
	// With any allocation strategy except BEST_FIT using On-Demand ( EC2 ) compute
	// resources, Batch might need to exceed maxvCpus to meet your capacity
	// requirements. In this event, Batch never exceeds maxvCpus by more than a single
	// instance.
	//
	// This member is required.
	MaxvCpus *int32

	// The type of compute environment: EC2 , SPOT , FARGATE , FARGATE_SPOT , or
	// ECS_MANAGED_INSTANCES . For more information, see [Compute environments] in the Batch User Guide.
	//
	// If you choose SPOT , you must also specify an Amazon EC2 Spot Fleet role with
	// the spotIamFleetRole parameter. For more information, see [Amazon EC2 spot fleet role] in the Batch User
	// Guide.
	//
	// If you choose ECS_MANAGED_INSTANCES , you must also specify a
	// managedInstancesProvider configuration. To use Spot capacity, set
	// capacityOptionType to SPOT in the
	// managedInstancesProvider.instanceLaunchTemplate configuration. For more
	// information, see [Amazon ECS Managed Instances compute environments]in the Batch User Guide.
	//
	// Multi-node parallel jobs aren't supported on Spot Instances or Amazon ECS
	// Managed Instances.
	//
	// [Amazon ECS Managed Instances compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/ecs_managed_instances.html
	// [Amazon EC2 spot fleet role]: https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html
	// [Compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html
	//
	// This member is required.
	Type CRType

	// The allocation strategy to use for the compute resource if not enough instances
	// of the best fitting instance type can be allocated. This might be because of
	// availability of the instance type in the Region or [Amazon EC2 service limits]. For more information, see [Allocation strategies]
	// in the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// This parameter is required for Amazon EKS compute environments. For Amazon ECS
	// compute environments, if this parameter isn't specified, the BEST_FIT
	// allocation strategy is used by default.
	//
	// BEST_FIT (default) Batch selects an instance type that best fits the needs of
	// the jobs with a preference for the lowest-cost instance type. If additional
	// instances of the selected instance type aren't available, Batch waits for the
	// additional instances to be available. If there aren't enough instances available
	// or the user is reaching [Amazon EC2 service limits], additional jobs aren't run until the currently
	// running jobs are completed. This allocation strategy keeps costs lower but can
	// limit scaling. If you're using Spot Fleets with BEST_FIT , the Spot Fleet IAM
	// Role must be specified. Compute resources that use a BEST_FIT allocation
	// strategy don't support infrastructure updates and can't update some parameters.
	// For more information, see [Updating compute environments]in the Batch User Guide.
	//
	// BEST_FIT_PROGRESSIVE Batch selects additional instance types that are large
	// enough to meet the requirements of the jobs in the queue. Its preference is for
	// instance types with lower cost vCPUs. If additional instances of the previously
	// selected instance types aren't available, Batch selects new instance types.
	//
	// BEST_FIT_PROGRESSIVE_ORDERED This is an advanced allocation strategy only for
	// customers who want to control which instance types are preferred during scaling.
	//
	// Placing large instance types at the top of the list may result in
	// over-provisioning for small jobs. Placing small instance types at the top may
	// cause the compute environment to reach Amazon EC2 instance count limits before
	// reaching maxvCpus .
	//
	// Batch selects instance types in the order they appear in the instanceTypes
	// list. When an instance family is specified, sizes within that family are
	// expanded using BEST_FIT_PROGRESSIVE logic—preferring sizes that best fit the
	// jobs, with larger sizes as fallback. Instance types that cannot meet the
	// resource requirements of the jobs are skipped. This strategy is only available
	// for On-Demand Instance ( EC2 ) compute resources.
	//
	// If an instance family and an explicit instance type from that family both
	// appear in instanceTypes , the explicit type takes its listed position and is
	// excluded from the family expansion. For example, in ["m7a.4xlarge", "m7a",
	// "m6a"] , m7a.4xlarge is always placed first and is excluded from the m7a family
	// expansion.
	//
	// SPOT_CAPACITY_OPTIMIZED Batch selects one or more instance types that are large
	// enough to meet the requirements of the jobs in the queue. Its preference is for
	// instance types that are less likely to be interrupted. This allocation strategy
	// is only available for Spot Instance compute resources.
	//
	// SPOT_PRICE_CAPACITY_OPTIMIZED The price and capacity optimized allocation
	// strategy looks at both price and capacity to select the Spot Instance pools that
	// are the least likely to be interrupted and have the lowest possible price. This
	// allocation strategy is only available for Spot Instance compute resources.
	//
	// SPOT_CAPACITY_OPTIMIZED_PRIORITIZED This is an advanced allocation strategy for
	// customers who want to influence instance type selection during scaling. This
	// strategy optimizes for capacity first, and honors instance type priorities on a
	// best-effort basis (priorities are honored when they do not significantly reduce
	// available Spot capacity).
	//
	// Placing large instance types at the top of the list may result in
	// over-provisioning for small jobs. Placing small instance types at the top may
	// cause the compute environment to reach Amazon EC2 instance count limits before
	// reaching maxvCpus .
	//
	// Batch selects instance types in the order they appear in the instanceTypes
	// list, but optimizes for capacity first. The customer-defined priority is honored
	// on a best-effort basis. When Spot Instance capacity pools are similarly
	// available, priority order is respected. When capacity is constrained, Batch
	// selects from the most available pools regardless of priority to minimize the
	// likelihood of Spot Instance interruptions. This strategy is only available for
	// Spot Instance compute resources.
	//
	// With any allocation strategy except BEST_FIT using On-Demand ( EC2 ) compute
	// resources, Batch might need to exceed maxvCpus to meet your capacity
	// requirements. In this event, Batch never exceeds maxvCpus by more than a single
	// instance.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [Allocation strategies]: https://docs.aws.amazon.com/batch/latest/userguide/allocation-strategies.html
	// [Amazon EC2 service limits]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html
	AllocationStrategy CRAllocationStrategy

	// The maximum percentage that a Spot Instance price can be when compared with the
	// On-Demand price for that instance type before instances are launched. For
	// example, if your maximum percentage is 20%, then the Spot price must be less
	// than 20% of the current On-Demand price for that Amazon EC2 instance. You always
	// pay the lowest (market) price and never more than your maximum percentage. If
	// you leave this field empty, the default value is 100% of the On-Demand price.
	// For most use cases, we recommend leaving this field empty.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	BidPercentage *int32

	// The tags to apply to the Amazon ECS capacity provider and Amazon EC2 instances
	// launched by the compute environment. These tags are separate from the compute
	// environment resource tags (the top-level tags parameter). Use capacityTags for
	// cost allocation and organization of the underlying infrastructure resources.
	//
	// This parameter is only valid for ECS_MANAGED_INSTANCES compute environments.
	// You must have the batch:SetCapacityTags permission on the compute environment
	// resource to use this parameter.
	CapacityTags map[string]string

	// The desired number of vCPUS in the compute environment. Batch modifies this
	// value between the minimum and maximum values based on job queue demand.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	DesiredvCpus *int32

	// Provides information that's used to select Amazon Machine Images (AMIs) for
	// Amazon EC2 instances in the compute environment. If Ec2Configuration isn't
	// specified, the default is ECS_AL2023 for EC2 (ECS) compute environments and
	// EKS_AL2023 for EKS compute environments.
	//
	// One or two values can be provided.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	Ec2Configuration []Ec2Configuration

	// The Amazon EC2 key pair that's used for instances launched in the compute
	// environment. You can use this key pair to log in to your instances with SSH.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	Ec2KeyPair *string

	// The Amazon Machine Image (AMI) ID used for instances launched in the compute
	// environment. This parameter is overridden by the imageIdOverride member of the
	// Ec2Configuration structure.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// The AMI that you choose for a compute environment must match the architecture
	// of the instance types that you intend to use for that compute environment. For
	// example, if your compute environment uses A1 instance types, the compute
	// resource AMI that you choose must support ARM instances. Amazon ECS vends both
	// x86 and ARM versions of the Amazon ECS-optimized Amazon Linux 2023 AMI. For more
	// information, see [Amazon ECS-optimized Amazon Linux 2023 AMI]in the Amazon Elastic Container Service Developer Guide.
	//
	// [Amazon ECS-optimized Amazon Linux 2023 AMI]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux-variants.html
	//
	// Deprecated: This field is deprecated, use ec2Configuration[].imageIdOverride
	// instead.
	ImageId *string

	// The Amazon ECS instance profile applied to Amazon EC2 instances in a compute
	// environment. This parameter is required for Amazon EC2 instances types. You can
	// specify the short name or full Amazon Resource Name (ARN) of an instance
	// profile. For example, ecsInstanceRole  or
	// arn:aws:iam:::instance-profile/ecsInstanceRole . For more information, see [Amazon ECS instance role] in
	// the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Amazon ECS instance role]: https://docs.aws.amazon.com/batch/latest/userguide/instance_IAM_role.html
	InstanceRole *string

	// The instances types that can be launched. You can specify instance families to
	// launch any instance type within those families (for example, c5 or p3 ), or you
	// can specify specific sizes within a family (such as c5.8xlarge ).
	//
	// Batch can select the instance type for you if you choose one of the following:
	//
	//   - default_x86_64 to choose x86 based instance types (from the m6i , c6i , r6i
	//   , and c7i instance families) that matches the resource demands of the job
	//   queue.
	//
	//   - default_arm64 to choose ARM based instance types (from the m6g , c6g , r6g ,
	//   and c7g instance families) that matches the resource demands of the job queue.
	//
	//   - optimal Semantically equivalent to default_x86_64 , see [Optimal instance type configuration to receive automatic instance family updates]for details.
	//
	// Instance family availability varies by Amazon Web Services Region. For example,
	// some Amazon Web Services Regions may not have any fourth generation instance
	// families but have fifth and sixth generation instance families.
	//
	// When using default_x86_64 or default_arm64 instance bundles, Batch selects
	// instance families based on a balance of cost-effectiveness and performance.
	// While newer generation instances often provide better price-performance, Batch
	// may choose an earlier generation instance family if it provides the optimal
	// combination of availability, cost, and performance for your workload. For
	// example, in an Amazon Web Services Region where both c6i and c7i instances are
	// available, Batch might select c6i instances if they offer better
	// cost-effectiveness for your specific job requirements. For more information on
	// Batch instance types and Amazon Web Services Region availability, see [Instance type compute table]in the
	// Batch User Guide.
	//
	// Batch periodically updates your instances in default bundles to newer, more
	// cost-effective options. Updates happen automatically without requiring any
	// action from you. Your workloads continue running during updates with no
	// interruption
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// When you create a compute environment, the instance types that you select for
	// the compute environment must share the same architecture. For example, you can't
	// mix x86 and ARM instances in the same compute environment.
	//
	// [Instance type compute table]: https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html
	// [Optimal instance type configuration to receive automatic instance family updates]: https://docs.aws.amazon.com/batch/latest/userguide/optimal-default-instance-troubleshooting.html
	InstanceTypes []string

	// The launch template to use for your compute resources. Any other compute
	// resource parameters that you specify in a [CreateComputeEnvironment]API operation override the same
	// parameters in the launch template. You must specify either the launch template
	// ID or launch template name in the request, but not both. For more information,
	// see [Launch template support]in the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [CreateComputeEnvironment]: https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html
	// [Launch template support]: https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html
	LaunchTemplate *LaunchTemplateSpecification

	// The configuration for the Amazon ECS Managed Instances capacity provider. This
	// parameter is required when computeResources.type is ECS_MANAGED_INSTANCES and
	// must not be specified for other compute environment types.
	//
	// For more information, see [Amazon ECS Managed Instances compute environments] in the Batch User Guide.
	//
	// [Amazon ECS Managed Instances compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/ecs_managed_instances.html
	ManagedInstancesProvider *ManagedInstancesProvider

	// The minimum number of vCPUs that a compute environment should maintain (even if
	// the compute environment is DISABLED ).
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	MinvCpus *int32

	// The Amazon EC2 placement group to associate with your compute resources. If you
	// intend to submit multi-node parallel jobs to your compute environment, you
	// should consider creating a cluster placement group and associate it with your
	// compute resources. This keeps your multi-node parallel job on a logical grouping
	// of instances within a single Availability Zone with high network flow potential.
	// For more information, see [Placement groups]in the Amazon EC2 User Guide for Linux Instances.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Placement groups]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
	PlacementGroup *string

	// The scaling policy configuration for the compute environment.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	ScalingPolicy *ComputeScalingPolicy

	// The Amazon EC2 security groups that are associated with instances launched in
	// the compute environment. One or more security groups must be specified, either
	// in securityGroupIds or using a launch template referenced in launchTemplate .
	// This parameter is required for jobs that are running on Fargate resources and
	// must contain at least one security group. Fargate doesn't support launch
	// templates. If security groups are specified using both securityGroupIds and
	// launchTemplate , the values in securityGroupIds are used.
	SecurityGroupIds []string

	// The Amazon Resource Name (ARN) of the Amazon EC2 Spot Fleet IAM role applied to
	// a SPOT compute environment. This role is required if the allocation strategy
	// set to BEST_FIT or if the allocation strategy isn't specified. For more
	// information, see [Amazon EC2 spot fleet role]in the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// To tag your Spot Instances on creation, the Spot Fleet IAM role specified here
	// must use the newer AmazonEC2SpotFleetTaggingRole managed policy. The previously
	// recommended AmazonEC2SpotFleetRole managed policy doesn't have the required
	// permissions to tag Spot Instances. For more information, see [Spot instances not tagged on creation]in the Batch User
	// Guide.
	//
	// [Spot instances not tagged on creation]: https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#spot-instance-no-tag
	// [Amazon EC2 spot fleet role]: https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html
	SpotIamFleetRole *string

	// The VPC subnets where the compute resources are launched. These subnets must be
	// within the same VPC. Fargate compute resources can contain up to 16 subnets. For
	// more information, see [VPCs and subnets]in the Amazon VPC User Guide. This parameter is required
	// for compute environments using EC2 , SPOT , FARGATE , or FARGATE_SPOT compute
	// resources.
	//
	// Batch on Amazon EC2 and Batch on Amazon EKS support Local Zones. For more
	// information, see [Local Zones]in the Amazon EC2 User Guide for Linux Instances, [Amazon EKS and Amazon Web Services Local Zones] in the
	// Amazon EKS User Guide and [Amazon ECS clusters in Local Zones, Wavelength Zones, and Amazon Web Services Outposts]in the Amazon ECS Developer Guide.
	//
	// Batch on Fargate doesn't currently support Local Zones.
	//
	// [VPCs and subnets]: https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html
	// [Amazon ECS clusters in Local Zones, Wavelength Zones, and Amazon Web Services Outposts]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-regions-zones.html#clusters-local-zones
	// [Local Zones]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-local-zones
	// [Amazon EKS and Amazon Web Services Local Zones]: https://docs.aws.amazon.com/eks/latest/userguide/local-zones.html
	Subnets []string

	// Key-value pair tags to be applied to Amazon EC2 resources that are launched in
	// the compute environment. For Batch, these take the form of "String1": "String2"
	// , where String1 is the tag key and String2 is the tag value (for example, {
	// "Name": "Batch Instance - C4OnDemand" } ). This is helpful for recognizing your
	// Batch instances in the Amazon EC2 console. Updating these tags requires an
	// infrastructure update to the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide. These tags aren't seen when using the Batch
	// ListTagsForResource API operation.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	Tags map[string]string

	noSmithyDocumentSerde
}

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

func (v *ComputeResource) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AllocationStrategy != "" {
		s.WriteString(schemas.ComputeResource_allocationStrategy, string(v.AllocationStrategy))
	}
	if v.BidPercentage != nil {
		s.WriteInt32(schemas.ComputeResource_bidPercentage, *v.BidPercentage)
	}
	if v.CapacityTags != nil {
		serializeTagrisTagsMap(s, schemas.ComputeResource_capacityTags, v.CapacityTags)
	}
	if v.DesiredvCpus != nil {
		s.WriteInt32(schemas.ComputeResource_desiredvCpus, *v.DesiredvCpus)
	}
	if v.Ec2Configuration != nil {
		serializeEc2ConfigurationList(s, schemas.ComputeResource_ec2Configuration, v.Ec2Configuration)
	}
	if v.Ec2KeyPair != nil {
		s.WriteString(schemas.ComputeResource_ec2KeyPair, *v.Ec2KeyPair)
	}
	if v.ImageId != nil {
		s.WriteString(schemas.ComputeResource_imageId, *v.ImageId)
	}
	if v.InstanceRole != nil {
		s.WriteString(schemas.ComputeResource_instanceRole, *v.InstanceRole)
	}
	if v.InstanceTypes != nil {
		serializeStringList(s, schemas.ComputeResource_instanceTypes, v.InstanceTypes)
	}
	if v.LaunchTemplate != nil {
		s.WriteStruct(schemas.ComputeResource_launchTemplate)
		v.LaunchTemplate.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ManagedInstancesProvider != nil {
		s.WriteStruct(schemas.ComputeResource_managedInstancesProvider)
		v.ManagedInstancesProvider.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.MaxvCpus != nil {
		s.WriteInt32(schemas.ComputeResource_maxvCpus, *v.MaxvCpus)
	}
	if v.MinvCpus != nil {
		s.WriteInt32(schemas.ComputeResource_minvCpus, *v.MinvCpus)
	}
	if v.PlacementGroup != nil {
		s.WriteString(schemas.ComputeResource_placementGroup, *v.PlacementGroup)
	}
	if v.ScalingPolicy != nil {
		s.WriteStruct(schemas.ComputeResource_scalingPolicy)
		v.ScalingPolicy.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SecurityGroupIds != nil {
		serializeStringList(s, schemas.ComputeResource_securityGroupIds, v.SecurityGroupIds)
	}
	if v.SpotIamFleetRole != nil {
		s.WriteString(schemas.ComputeResource_spotIamFleetRole, *v.SpotIamFleetRole)
	}
	if v.Subnets != nil {
		serializeStringList(s, schemas.ComputeResource_subnets, v.Subnets)
	}
	if v.Tags != nil {
		serializeTagsMap(s, schemas.ComputeResource_tags, v.Tags)
	}
	if v.Type != "" {
		s.WriteString(schemas.ComputeResource_type, string(v.Type))
	}
}
func (v *ComputeResource) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ComputeResource, func(s *smithy.Schema) error {
		switch s {
		case schemas.ComputeResource_allocationStrategy:
			var ev string
			if err := d.ReadString(schemas.ComputeResource_allocationStrategy, &ev); err != nil {
				return err
			}
			v.AllocationStrategy = CRAllocationStrategy(ev)
			return nil
		case schemas.ComputeResource_bidPercentage:
			v.BidPercentage = new(int32)
			return d.ReadInt32(schemas.ComputeResource_bidPercentage, v.BidPercentage)
		case schemas.ComputeResource_capacityTags:
			return deserializeTagrisTagsMap(d, schemas.ComputeResource_capacityTags, &v.CapacityTags)
		case schemas.ComputeResource_desiredvCpus:
			v.DesiredvCpus = new(int32)
			return d.ReadInt32(schemas.ComputeResource_desiredvCpus, v.DesiredvCpus)
		case schemas.ComputeResource_ec2Configuration:
			return deserializeEc2ConfigurationList(d, schemas.ComputeResource_ec2Configuration, &v.Ec2Configuration)
		case schemas.ComputeResource_ec2KeyPair:
			v.Ec2KeyPair = new(string)
			return d.ReadString(schemas.ComputeResource_ec2KeyPair, v.Ec2KeyPair)
		case schemas.ComputeResource_imageId:
			v.ImageId = new(string)
			return d.ReadString(schemas.ComputeResource_imageId, v.ImageId)
		case schemas.ComputeResource_instanceRole:
			v.InstanceRole = new(string)
			return d.ReadString(schemas.ComputeResource_instanceRole, v.InstanceRole)
		case schemas.ComputeResource_instanceTypes:
			return deserializeStringList(d, schemas.ComputeResource_instanceTypes, &v.InstanceTypes)
		case schemas.ComputeResource_launchTemplate:
			v.LaunchTemplate = &LaunchTemplateSpecification{}
			return v.LaunchTemplate.Deserialize(d)
		case schemas.ComputeResource_managedInstancesProvider:
			v.ManagedInstancesProvider = &ManagedInstancesProvider{}
			return v.ManagedInstancesProvider.Deserialize(d)
		case schemas.ComputeResource_maxvCpus:
			v.MaxvCpus = new(int32)
			return d.ReadInt32(schemas.ComputeResource_maxvCpus, v.MaxvCpus)
		case schemas.ComputeResource_minvCpus:
			v.MinvCpus = new(int32)
			return d.ReadInt32(schemas.ComputeResource_minvCpus, v.MinvCpus)
		case schemas.ComputeResource_placementGroup:
			v.PlacementGroup = new(string)
			return d.ReadString(schemas.ComputeResource_placementGroup, v.PlacementGroup)
		case schemas.ComputeResource_scalingPolicy:
			v.ScalingPolicy = &ComputeScalingPolicy{}
			return v.ScalingPolicy.Deserialize(d)
		case schemas.ComputeResource_securityGroupIds:
			return deserializeStringList(d, schemas.ComputeResource_securityGroupIds, &v.SecurityGroupIds)
		case schemas.ComputeResource_spotIamFleetRole:
			v.SpotIamFleetRole = new(string)
			return d.ReadString(schemas.ComputeResource_spotIamFleetRole, v.SpotIamFleetRole)
		case schemas.ComputeResource_subnets:
			return deserializeStringList(d, schemas.ComputeResource_subnets, &v.Subnets)
		case schemas.ComputeResource_tags:
			return deserializeTagsMap(d, schemas.ComputeResource_tags, &v.Tags)
		case schemas.ComputeResource_type:
			var ev string
			if err := d.ReadString(schemas.ComputeResource_type, &ev); err != nil {
				return err
			}
			v.Type = CRType(ev)
			return nil
		}
		return nil
	})
}

// An object that represents the attributes of a compute environment that can be
// updated. For more information, see [Updating compute environments]in the Batch User Guide.
//
// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
type ComputeResourceUpdate struct {

	// The allocation strategy to use for the compute resource if there's not enough
	// instances of the best fitting instance type that can be allocated. This might be
	// because of availability of the instance type in the Region or [Amazon EC2 service limits]. For more
	// information, see [Allocation strategies]in the Batch User Guide.
	//
	// When updating a compute environment, changing the allocation strategy requires
	// an infrastructure update of the compute environment. For more information, see [Updating compute environments]
	// in the Batch User Guide. BEST_FIT isn't supported when updating a compute
	// environment.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// BEST_FIT_PROGRESSIVE Batch selects additional instance types that are large
	// enough to meet the requirements of the jobs in the queue. Its preference is for
	// instance types with lower cost vCPUs. If additional instances of the previously
	// selected instance types aren't available, Batch selects new instance types.
	//
	// BEST_FIT_PROGRESSIVE_ORDERED This is an advanced allocation strategy only for
	// customers who want to control which instance types are preferred during scaling.
	//
	// Placing large instance types at the top of the list may result in
	// over-provisioning for small jobs. Placing small instance types at the top may
	// cause the compute environment to reach Amazon EC2 instance count limits before
	// reaching maxvCpus .
	//
	// Batch selects instance types in the order they appear in the instanceTypes
	// list. When an instance family is specified, sizes within that family are
	// expanded using BEST_FIT_PROGRESSIVE logic—preferring sizes that best fit the
	// jobs, with larger sizes as fallback. Instance types that cannot meet the
	// resource requirements of the jobs are skipped. This strategy is only available
	// for On-Demand Instance ( EC2 ) compute resources.
	//
	// If an instance family and an explicit instance type from that family both
	// appear in instanceTypes , the explicit type takes its listed position and is
	// excluded from the family expansion. For example, in ["m7a.4xlarge", "m7a",
	// "m6a"] , m7a.4xlarge is always placed first and is excluded from the m7a family
	// expansion.
	//
	// SPOT_CAPACITY_OPTIMIZED Batch selects one or more instance types that are large
	// enough to meet the requirements of the jobs in the queue. Its preference is for
	// instance types that are less likely to be interrupted. This allocation strategy
	// is only available for Spot Instance compute resources.
	//
	// SPOT_PRICE_CAPACITY_OPTIMIZED The price and capacity optimized allocation
	// strategy looks at both price and capacity to select the Spot Instance pools that
	// are the least likely to be interrupted and have the lowest possible price. This
	// allocation strategy is only available for Spot Instance compute resources.
	//
	// SPOT_CAPACITY_OPTIMIZED_PRIORITIZED This is an advanced allocation strategy for
	// customers who want to influence instance type selection during scaling. This
	// strategy optimizes for capacity first, and honors instance type priorities on a
	// best-effort basis (priorities are honored when they do not significantly reduce
	// available Spot capacity).
	//
	// Placing large instance types at the top of the list may result in
	// over-provisioning for small jobs. Placing small instance types at the top may
	// cause the compute environment to reach Amazon EC2 instance count limits before
	// reaching maxvCpus .
	//
	// Batch selects instance types in the order they appear in the instanceTypes
	// list, but optimizes for capacity first. The customer-defined priority is honored
	// on a best-effort basis. When Spot Instance capacity pools are similarly
	// available, priority order is respected. When capacity is constrained, Batch
	// selects from the most available pools regardless of priority to minimize the
	// likelihood of Spot Instance interruptions. This strategy is only available for
	// Spot Instance compute resources.
	//
	// With any allocation strategy except BEST_FIT using On-Demand ( EC2 ) compute
	// resources, Batch might need to exceed maxvCpus to meet your capacity
	// requirements. In this event, Batch never exceeds maxvCpus by more than a single
	// instance.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [Allocation strategies]: https://docs.aws.amazon.com/batch/latest/userguide/allocation-strategies.html
	// [Amazon EC2 service limits]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html
	AllocationStrategy CRUpdateAllocationStrategy

	// The maximum percentage that a Spot Instance price can be when compared with the
	// On-Demand price for that instance type before instances are launched. For
	// example, if your maximum percentage is 20%, the Spot price must be less than 20%
	// of the current On-Demand price for that Amazon EC2 instance. You always pay the
	// lowest (market) price and never more than your maximum percentage. For most use
	// cases, we recommend leaving this field empty.
	//
	// When updating a compute environment, changing the bid percentage requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	BidPercentage *int32

	// The updated tags to apply to the Amazon ECS capacity provider and Amazon EC2
	// instances. This parameter is only valid for ECS_MANAGED_INSTANCES compute
	// environments. You must have the batch:SetCapacityTags permission on the compute
	// environment resource to use this parameter.
	CapacityTags map[string]string

	// The desired number of vCPUS in the compute environment. Batch modifies this
	// value between the minimum and maximum values based on job queue demand.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// Batch doesn't support changing the desired number of vCPUs of an existing
	// compute environment. Don't specify this parameter for compute environments using
	// Amazon EKS clusters.
	//
	// When you update the desiredvCpus setting, the value must be between the minvCpus
	// and maxvCpus values.
	//
	// Additionally, the updated desiredvCpus value must be greater than or equal to
	// the current desiredvCpus value. For more information, see [Troubleshooting Batch] in the Batch User
	// Guide.
	//
	// [Troubleshooting Batch]: https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#error-desired-vcpus-update
	DesiredvCpus *int32

	// Provides information used to select Amazon Machine Images (AMIs) for Amazon EC2
	// instances in the compute environment. If Ec2Configuration isn't specified, the
	// default is ECS_AL2023 for EC2 (ECS) compute environments and EKS_AL2023 for EKS
	// compute environments.
	//
	// When updating a compute environment, changing this setting requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide. To remove the Amazon EC2 configuration and any custom AMI
	// ID specified in imageIdOverride , set this value to an empty string.
	//
	// One or two values can be provided.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	Ec2Configuration []Ec2Configuration

	// The Amazon EC2 key pair that's used for instances launched in the compute
	// environment. You can use this key pair to log in to your instances with SSH. To
	// remove the Amazon EC2 key pair, set this value to an empty string.
	//
	// When updating a compute environment, changing the Amazon EC2 key pair requires
	// an infrastructure update of the compute environment. For more information, see [Updating compute environments]
	// in the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	Ec2KeyPair *string

	// The Amazon Machine Image (AMI) ID used for instances launched in the compute
	// environment. This parameter is overridden by the imageIdOverride member of the
	// Ec2Configuration structure. To remove the custom AMI ID and use the default AMI
	// ID, set this value to an empty string.
	//
	// When updating a compute environment, changing the AMI ID requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// The AMI that you choose for a compute environment must match the architecture
	// of the instance types that you intend to use for that compute environment. For
	// example, if your compute environment uses A1 instance types, the compute
	// resource AMI that you choose must support ARM instances. Amazon ECS vends both
	// x86 and ARM versions of the Amazon ECS-optimized Amazon Linux 2023 AMI. For more
	// information, see [Amazon ECS-optimized Amazon Linux 2023 AMI]in the Amazon Elastic Container Service Developer Guide.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [Amazon ECS-optimized Amazon Linux 2023 AMI]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux-variants.html
	ImageId *string

	// The Amazon ECS instance profile applied to Amazon EC2 instances in a compute
	// environment. Required for Amazon EC2 instances. You can specify the short name
	// or full Amazon Resource Name (ARN) of an instance profile. For example,
	// ecsInstanceRole or arn:aws:iam:::instance-profile/ecsInstanceRole . For more
	// information, see [Amazon ECS instance role]in the Batch User Guide.
	//
	// When updating a compute environment, changing this setting requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [Amazon ECS instance role]: https://docs.aws.amazon.com/batch/latest/userguide/instance_IAM_role.html
	InstanceRole *string

	// The instances types that can be launched. You can specify instance families to
	// launch any instance type within those families (for example, c5 or p3 ), or you
	// can specify specific sizes within a family (such as c5.8xlarge ).
	//
	// Batch can select the instance type for you if you choose one of the following:
	//
	//   - optimal to select instance types (from the c4 , m4 , r4 , c5 , m5 , and r5
	//   instance families) that match the demand of your job queues.
	//
	//   - default_x86_64 to choose x86 based instance types (from the m6i , c6i , r6i
	//   , and c7i instance families) that matches the resource demands of the job
	//   queue.
	//
	//   - default_arm64 to choose x86 based instance types (from the m6g , c6g , r6g ,
	//   and c7g instance families) that matches the resource demands of the job queue.
	//
	// Starting on 11/01/2025 the behavior of optimal is going to be changed to match
	// default_x86_64 . During the change your instance families could be updated to a
	// newer generation. You do not need to perform any actions for the upgrade to
	// happen. For more information about change, see [Optimal instance type configuration to receive automatic instance family updates].
	//
	// Instance family availability varies by Amazon Web Services Region. For example,
	// some Amazon Web Services Regions may not have any fourth generation instance
	// families but have fifth and sixth generation instance families.
	//
	// When using default_x86_64 or default_arm64 instance bundles, Batch selects
	// instance families based on a balance of cost-effectiveness and performance.
	// While newer generation instances often provide better price-performance, Batch
	// may choose an earlier generation instance family if it provides the optimal
	// combination of availability, cost, and performance for your workload. For
	// example, in an Amazon Web Services Region where both c6i and c7i instances are
	// available, Batch might select c6i instances if they offer better
	// cost-effectiveness for your specific job requirements. For more information on
	// Batch instance types and Amazon Web Services Region availability, see [Instance type compute table]in the
	// Batch User Guide.
	//
	// Batch periodically updates your instances in default bundles to newer, more
	// cost-effective options. Updates happen automatically without requiring any
	// action from you. Your workloads continue running during updates with no
	// interruption
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// When you create a compute environment, the instance types that you select for
	// the compute environment must share the same architecture. For example, you can't
	// mix x86 and ARM instances in the same compute environment.
	//
	// [Instance type compute table]: https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html
	// [Optimal instance type configuration to receive automatic instance family updates]: https://docs.aws.amazon.com/batch/latest/userguide/optimal-default-instance-troubleshooting.html
	InstanceTypes []string

	// The updated launch template to use for your compute resources. You must specify
	// either the launch template ID or launch template name in the request, but not
	// both. For more information, see [Launch template support]in the Batch User Guide. To remove the custom
	// launch template and use the default launch template, set launchTemplateId or
	// launchTemplateName member of the launch template specification to an empty
	// string. Removing the launch template from a compute environment will not remove
	// the AMI specified in the launch template. In order to update the AMI specified
	// in a launch template, the updateToLatestImageVersion parameter must be set to
	// true .
	//
	// When updating a compute environment, changing the launch template requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [Launch template support]: https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html
	LaunchTemplate *LaunchTemplateSpecification

	// The updated configuration for the Amazon ECS Managed Instances capacity
	// provider. This parameter is only valid when the compute environment type is
	// ECS_MANAGED_INSTANCES . You cannot change capacityOptionType or fipsEnabled on
	// update.
	ManagedInstancesProvider *UpdateManagedInstancesProviderConfiguration

	// The maximum number of Amazon EC2 vCPUs that an environment can reach.
	//
	// With any allocation strategy except BEST_FIT using On-Demand ( EC2 ) compute
	// resources, Batch might need to exceed maxvCpus to meet your capacity
	// requirements. In this event, Batch never exceeds maxvCpus by more than a single
	// instance.
	MaxvCpus *int32

	// The minimum number of vCPUs that an environment should maintain (even if the
	// compute environment is DISABLED ).
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	MinvCpus *int32

	// The Amazon EC2 placement group to associate with your compute resources. If you
	// intend to submit multi-node parallel jobs to your compute environment, you
	// should consider creating a cluster placement group and associate it with your
	// compute resources. This keeps your multi-node parallel job on a logical grouping
	// of instances within a single Availability Zone with high network flow potential.
	// For more information, see [Placement groups]in the Amazon EC2 User Guide for Linux Instances.
	//
	// When updating a compute environment, changing the placement group requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [Placement groups]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
	PlacementGroup *string

	// The scaling policy configuration for the compute environment.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	ScalingPolicy *ComputeScalingPolicy

	// The Amazon EC2 security groups that are associated with instances launched in
	// the compute environment. This parameter is required for Fargate compute
	// resources, where it can contain up to 5 security groups. For Fargate compute
	// resources, providing an empty list is handled as if this parameter wasn't
	// specified and no change is made. For Amazon EC2 compute resources, providing an
	// empty list removes the security groups from the compute resource.
	//
	// When updating a compute environment, changing the Amazon EC2 security groups
	// requires an infrastructure update of the compute environment. For more
	// information, see [Updating compute environments]in the Batch User Guide.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	SecurityGroupIds []string

	// The VPC subnets where the compute resources are launched. Fargate compute
	// resources can contain up to 16 subnets. For Fargate compute resources, providing
	// an empty list will be handled as if this parameter wasn't specified and no
	// change is made. For Amazon EC2 compute resources, providing an empty list
	// removes the VPC subnets from the compute resource. For more information, see [VPCs and subnets]in
	// the Amazon VPC User Guide.
	//
	// When updating a compute environment, changing the VPC subnets requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide.
	//
	// Batch on Amazon EC2 and Batch on Amazon EKS support Local Zones. For more
	// information, see [Local Zones]in the Amazon EC2 User Guide for Linux Instances, [Amazon EKS and Amazon Web Services Local Zones] in the
	// Amazon EKS User Guide and [Amazon ECS clusters in Local Zones, Wavelength Zones, and Amazon Web Services Outposts]in the Amazon ECS Developer Guide.
	//
	// Batch on Fargate doesn't currently support Local Zones.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [VPCs and subnets]: https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html
	// [Amazon ECS clusters in Local Zones, Wavelength Zones, and Amazon Web Services Outposts]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-regions-zones.html#clusters-local-zones
	// [Local Zones]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-local-zones
	// [Amazon EKS and Amazon Web Services Local Zones]: https://docs.aws.amazon.com/eks/latest/userguide/local-zones.html
	Subnets []string

	// Key-value pair tags to be applied to Amazon EC2 resources that are launched in
	// the compute environment. For Batch, these take the form of "String1": "String2"
	// , where String1 is the tag key and String2 is the tag value (for example, {
	// "Name": "Batch Instance - C4OnDemand" } ). This is helpful for recognizing your
	// Batch instances in the Amazon EC2 console. These tags aren't seen when using the
	// Batch ListTagsForResource API operation.
	//
	// When updating a compute environment, changing this setting requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't specify it.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	Tags map[string]string

	// The type of compute environment: EC2 , SPOT , FARGATE , FARGATE_SPOT , or
	// ECS_MANAGED_INSTANCES . For more information, see [Compute environments] in the Batch User Guide.
	//
	// If you choose SPOT , you must also specify an Amazon EC2 Spot Fleet role with
	// the spotIamFleetRole parameter. For more information, see [Amazon EC2 spot fleet role] in the Batch User
	// Guide.
	//
	// When updating a compute environment, changing the type of a compute environment
	// requires an infrastructure update of the compute environment. For more
	// information, see [Updating compute environments]in the Batch User Guide.
	//
	// You cannot change the type to or from ECS_MANAGED_INSTANCES .
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [Amazon EC2 spot fleet role]: https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html
	// [Compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html
	Type CRType

	// Specifies whether the AMI ID is updated to the latest one that's supported by
	// Batch when the compute environment has an infrastructure update. The default
	// value is false .
	//
	// An AMI ID can either be specified in the imageId or imageIdOverride parameters
	// or be determined by the launch template that's specified in the launchTemplate
	// parameter. If an AMI ID is specified any of these ways, this parameter is
	// ignored. For more information about to update AMI IDs during an infrastructure
	// update, see [Updating the AMI ID]in the Batch User Guide.
	//
	// When updating a compute environment, changing this setting requires an
	// infrastructure update of the compute environment. For more information, see [Updating compute environments]in
	// the Batch User Guide.
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	// [Updating the AMI ID]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html#updating-compute-environments-ami
	UpdateToLatestImageVersion *bool

	noSmithyDocumentSerde
}

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

func (v *ComputeResourceUpdate) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AllocationStrategy != "" {
		s.WriteString(schemas.ComputeResourceUpdate_allocationStrategy, string(v.AllocationStrategy))
	}
	if v.BidPercentage != nil {
		s.WriteInt32(schemas.ComputeResourceUpdate_bidPercentage, *v.BidPercentage)
	}
	if v.CapacityTags != nil {
		serializeTagrisTagsMap(s, schemas.ComputeResourceUpdate_capacityTags, v.CapacityTags)
	}
	if v.DesiredvCpus != nil {
		s.WriteInt32(schemas.ComputeResourceUpdate_desiredvCpus, *v.DesiredvCpus)
	}
	if v.Ec2Configuration != nil {
		serializeEc2ConfigurationList(s, schemas.ComputeResourceUpdate_ec2Configuration, v.Ec2Configuration)
	}
	if v.Ec2KeyPair != nil {
		s.WriteString(schemas.ComputeResourceUpdate_ec2KeyPair, *v.Ec2KeyPair)
	}
	if v.ImageId != nil {
		s.WriteString(schemas.ComputeResourceUpdate_imageId, *v.ImageId)
	}
	if v.InstanceRole != nil {
		s.WriteString(schemas.ComputeResourceUpdate_instanceRole, *v.InstanceRole)
	}
	if v.InstanceTypes != nil {
		serializeStringList(s, schemas.ComputeResourceUpdate_instanceTypes, v.InstanceTypes)
	}
	if v.LaunchTemplate != nil {
		s.WriteStruct(schemas.ComputeResourceUpdate_launchTemplate)
		v.LaunchTemplate.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ManagedInstancesProvider != nil {
		s.WriteStruct(schemas.ComputeResourceUpdate_managedInstancesProvider)
		v.ManagedInstancesProvider.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.MaxvCpus != nil {
		s.WriteInt32(schemas.ComputeResourceUpdate_maxvCpus, *v.MaxvCpus)
	}
	if v.MinvCpus != nil {
		s.WriteInt32(schemas.ComputeResourceUpdate_minvCpus, *v.MinvCpus)
	}
	if v.PlacementGroup != nil {
		s.WriteString(schemas.ComputeResourceUpdate_placementGroup, *v.PlacementGroup)
	}
	if v.ScalingPolicy != nil {
		s.WriteStruct(schemas.ComputeResourceUpdate_scalingPolicy)
		v.ScalingPolicy.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SecurityGroupIds != nil {
		serializeStringList(s, schemas.ComputeResourceUpdate_securityGroupIds, v.SecurityGroupIds)
	}
	if v.Subnets != nil {
		serializeStringList(s, schemas.ComputeResourceUpdate_subnets, v.Subnets)
	}
	if v.Tags != nil {
		serializeTagsMap(s, schemas.ComputeResourceUpdate_tags, v.Tags)
	}
	if v.Type != "" {
		s.WriteString(schemas.ComputeResourceUpdate_type, string(v.Type))
	}
	if v.UpdateToLatestImageVersion != nil {
		s.WriteBool(schemas.ComputeResourceUpdate_updateToLatestImageVersion, *v.UpdateToLatestImageVersion)
	}
}
func (v *ComputeResourceUpdate) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ComputeResourceUpdate, func(s *smithy.Schema) error {
		switch s {
		case schemas.ComputeResourceUpdate_allocationStrategy:
			var ev string
			if err := d.ReadString(schemas.ComputeResourceUpdate_allocationStrategy, &ev); err != nil {
				return err
			}
			v.AllocationStrategy = CRUpdateAllocationStrategy(ev)
			return nil
		case schemas.ComputeResourceUpdate_bidPercentage:
			v.BidPercentage = new(int32)
			return d.ReadInt32(schemas.ComputeResourceUpdate_bidPercentage, v.BidPercentage)
		case schemas.ComputeResourceUpdate_capacityTags:
			return deserializeTagrisTagsMap(d, schemas.ComputeResourceUpdate_capacityTags, &v.CapacityTags)
		case schemas.ComputeResourceUpdate_desiredvCpus:
			v.DesiredvCpus = new(int32)
			return d.ReadInt32(schemas.ComputeResourceUpdate_desiredvCpus, v.DesiredvCpus)
		case schemas.ComputeResourceUpdate_ec2Configuration:
			return deserializeEc2ConfigurationList(d, schemas.ComputeResourceUpdate_ec2Configuration, &v.Ec2Configuration)
		case schemas.ComputeResourceUpdate_ec2KeyPair:
			v.Ec2KeyPair = new(string)
			return d.ReadString(schemas.ComputeResourceUpdate_ec2KeyPair, v.Ec2KeyPair)
		case schemas.ComputeResourceUpdate_imageId:
			v.ImageId = new(string)
			return d.ReadString(schemas.ComputeResourceUpdate_imageId, v.ImageId)
		case schemas.ComputeResourceUpdate_instanceRole:
			v.InstanceRole = new(string)
			return d.ReadString(schemas.ComputeResourceUpdate_instanceRole, v.InstanceRole)
		case schemas.ComputeResourceUpdate_instanceTypes:
			return deserializeStringList(d, schemas.ComputeResourceUpdate_instanceTypes, &v.InstanceTypes)
		case schemas.ComputeResourceUpdate_launchTemplate:
			v.LaunchTemplate = &LaunchTemplateSpecification{}
			return v.LaunchTemplate.Deserialize(d)
		case schemas.ComputeResourceUpdate_managedInstancesProvider:
			v.ManagedInstancesProvider = &UpdateManagedInstancesProviderConfiguration{}
			return v.ManagedInstancesProvider.Deserialize(d)
		case schemas.ComputeResourceUpdate_maxvCpus:
			v.MaxvCpus = new(int32)
			return d.ReadInt32(schemas.ComputeResourceUpdate_maxvCpus, v.MaxvCpus)
		case schemas.ComputeResourceUpdate_minvCpus:
			v.MinvCpus = new(int32)
			return d.ReadInt32(schemas.ComputeResourceUpdate_minvCpus, v.MinvCpus)
		case schemas.ComputeResourceUpdate_placementGroup:
			v.PlacementGroup = new(string)
			return d.ReadString(schemas.ComputeResourceUpdate_placementGroup, v.PlacementGroup)
		case schemas.ComputeResourceUpdate_scalingPolicy:
			v.ScalingPolicy = &ComputeScalingPolicy{}
			return v.ScalingPolicy.Deserialize(d)
		case schemas.ComputeResourceUpdate_securityGroupIds:
			return deserializeStringList(d, schemas.ComputeResourceUpdate_securityGroupIds, &v.SecurityGroupIds)
		case schemas.ComputeResourceUpdate_subnets:
			return deserializeStringList(d, schemas.ComputeResourceUpdate_subnets, &v.Subnets)
		case schemas.ComputeResourceUpdate_tags:
			return deserializeTagsMap(d, schemas.ComputeResourceUpdate_tags, &v.Tags)
		case schemas.ComputeResourceUpdate_type:
			var ev string
			if err := d.ReadString(schemas.ComputeResourceUpdate_type, &ev); err != nil {
				return err
			}
			v.Type = CRType(ev)
			return nil
		case schemas.ComputeResourceUpdate_updateToLatestImageVersion:
			v.UpdateToLatestImageVersion = new(bool)
			return d.ReadBool(schemas.ComputeResourceUpdate_updateToLatestImageVersion, v.UpdateToLatestImageVersion)
		}
		return nil
	})
}

// An object that represents a scaling policy for a compute environment.
type ComputeScalingPolicy struct {

	// The minimum time (in minutes) that Batch keeps instances running in the compute
	// environment after their jobs complete. For each instance, the delay period
	// begins when the last job finishes. If no new jobs are placed on the instance
	// during this delay, Batch terminates the instance once the delay expires.
	//
	// Valid Range: Minimum value of 20. Maximum value of 10080. Use 0 to unset and
	// disable the scale down delay.
	//
	// Idle instances retained during the scale-down delay period are billable at
	// standard EC2 pricing.
	//
	// The scale down delay does not apply to:
	//
	//   - Instances being replaced during infrastructure updates
	//
	//   - Newly launched instances that have not yet run any jobs
	//
	//   - Spot instances reclaimed due to interruption
	MinScaleDownDelayMinutes *int32

	noSmithyDocumentSerde
}

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

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

// Contains a list of consumable resources required by a job.
type ConsumableResourceProperties struct {

	// The list of consumable resources required by a job.
	ConsumableResourceList []ConsumableResourceRequirement

	noSmithyDocumentSerde
}

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

func (v *ConsumableResourceProperties) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ConsumableResourceList != nil {
		serializeConsumableResourceList(s, schemas.ConsumableResourceProperties_consumableResourceList, v.ConsumableResourceList)
	}
}
func (v *ConsumableResourceProperties) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ConsumableResourceProperties, func(s *smithy.Schema) error {
		switch s {
		case schemas.ConsumableResourceProperties_consumableResourceList:
			return deserializeConsumableResourceList(d, schemas.ConsumableResourceProperties_consumableResourceList, &v.ConsumableResourceList)
		}
		return nil
	})
}

// Information about a consumable resource required to run a job.
type ConsumableResourceRequirement struct {

	// The name or ARN of the consumable resource.
	ConsumableResource *string

	// The quantity of the consumable resource that is needed.
	Quantity *int64

	noSmithyDocumentSerde
}

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

func (v *ConsumableResourceRequirement) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ConsumableResource != nil {
		s.WriteString(schemas.ConsumableResourceRequirement_consumableResource, *v.ConsumableResource)
	}
	if v.Quantity != nil {
		s.WriteInt64(schemas.ConsumableResourceRequirement_quantity, *v.Quantity)
	}
}
func (v *ConsumableResourceRequirement) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ConsumableResourceRequirement, func(s *smithy.Schema) error {
		switch s {
		case schemas.ConsumableResourceRequirement_consumableResource:
			v.ConsumableResource = new(string)
			return d.ReadString(schemas.ConsumableResourceRequirement_consumableResource, v.ConsumableResource)
		case schemas.ConsumableResourceRequirement_quantity:
			v.Quantity = new(int64)
			return d.ReadInt64(schemas.ConsumableResourceRequirement_quantity, v.Quantity)
		}
		return nil
	})
}

// Current information about a consumable resource.
type ConsumableResourceSummary struct {

	// The Amazon Resource Name (ARN) of the consumable resource.
	//
	// This member is required.
	ConsumableResourceArn *string

	// The name of the consumable resource.
	//
	// This member is required.
	ConsumableResourceName *string

	// The amount of the consumable resource that is currently in use.
	InUseQuantity *int64

	// Indicates whether the resource is available to be re-used after a job
	// completes. Can be one of:
	//
	//   - REPLENISHABLE
	//
	//   - NON_REPLENISHABLE
	ResourceType *string

	// The total amount of the consumable resource that is available.
	TotalQuantity *int64

	noSmithyDocumentSerde
}

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

func (v *ConsumableResourceSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ConsumableResourceArn != nil {
		s.WriteString(schemas.ConsumableResourceSummary_consumableResourceArn, *v.ConsumableResourceArn)
	}
	if v.ConsumableResourceName != nil {
		s.WriteString(schemas.ConsumableResourceSummary_consumableResourceName, *v.ConsumableResourceName)
	}
	if v.InUseQuantity != nil {
		s.WriteInt64(schemas.ConsumableResourceSummary_inUseQuantity, *v.InUseQuantity)
	}
	if v.ResourceType != nil {
		s.WriteString(schemas.ConsumableResourceSummary_resourceType, *v.ResourceType)
	}
	if v.TotalQuantity != nil {
		s.WriteInt64(schemas.ConsumableResourceSummary_totalQuantity, *v.TotalQuantity)
	}
}
func (v *ConsumableResourceSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ConsumableResourceSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.ConsumableResourceSummary_consumableResourceArn:
			v.ConsumableResourceArn = new(string)
			return d.ReadString(schemas.ConsumableResourceSummary_consumableResourceArn, v.ConsumableResourceArn)
		case schemas.ConsumableResourceSummary_consumableResourceName:
			v.ConsumableResourceName = new(string)
			return d.ReadString(schemas.ConsumableResourceSummary_consumableResourceName, v.ConsumableResourceName)
		case schemas.ConsumableResourceSummary_inUseQuantity:
			v.InUseQuantity = new(int64)
			return d.ReadInt64(schemas.ConsumableResourceSummary_inUseQuantity, v.InUseQuantity)
		case schemas.ConsumableResourceSummary_resourceType:
			v.ResourceType = new(string)
			return d.ReadString(schemas.ConsumableResourceSummary_resourceType, v.ResourceType)
		case schemas.ConsumableResourceSummary_totalQuantity:
			v.TotalQuantity = new(int64)
			return d.ReadInt64(schemas.ConsumableResourceSummary_totalQuantity, v.TotalQuantity)
		}
		return nil
	})
}

// An object that represents the details of a container that's part of a job.
type ContainerDetail struct {

	// The command that's passed to the container.
	Command []string

	// The Amazon Resource Name (ARN) of the container instance that the container is
	// running on.
	ContainerInstanceArn *string

	// Determines whether execute command functionality is turned on for this task. If
	// true , execute command functionality is turned on all the containers in the task.
	EnableExecuteCommand *bool

	// The environment variables to pass to a container.
	//
	// Environment variables cannot start with " AWS_BATCH ". This naming convention is
	// reserved for variables that Batch sets.
	Environment []KeyValuePair

	// The amount of ephemeral storage allocated for the task. This parameter is used
	// to expand the total amount of ephemeral storage available, beyond the default
	// amount, for tasks hosted on Fargate.
	EphemeralStorage *EphemeralStorage

	// The Amazon Resource Name (ARN) of the execution role that Batch can assume. For
	// more information, see [Batch execution IAM role]in the Batch User Guide.
	//
	// [Batch execution IAM role]: https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html
	ExecutionRoleArn *string

	// The exit code returned upon completion.
	ExitCode *int32

	// The platform configuration for jobs that are running on Fargate resources. Jobs
	// that are running on Amazon EC2 resources must not specify this parameter.
	FargatePlatformConfiguration *FargatePlatformConfiguration

	// The image used to start the container.
	Image *string

	// The instance type of the underlying host infrastructure of a multi-node
	// parallel job.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	InstanceType *string

	// The Amazon Resource Name (ARN) that's associated with the job when run.
	JobRoleArn *string

	// Linux-specific modifications that are applied to the container, such as details
	// for device mappings.
	LinuxParameters *LinuxParameters

	// The log configuration specification for the container.
	//
	// This parameter maps to LogConfig in the [Create a container] section of the [Docker Remote API] and the --log-driver
	// option to [docker run]. By default, containers use the same logging driver that the Docker
	// daemon uses. However, the container might use a different logging driver than
	// the Docker daemon by specifying a log driver with this parameter in the
	// container definition. To use a different logging driver for a container, the log
	// system must be configured properly on the container instance. Or, alternatively,
	// it must be configured on a different log server for remote logging options. For
	// more information on the options for different supported log drivers, see [Configure logging drivers]in the
	// Docker documentation.
	//
	// Batch currently supports a subset of the logging drivers available to the
	// Docker daemon (shown in the [LogConfiguration]data type). Additional log drivers might be
	// available in future releases of the Amazon ECS container agent.
	//
	// This parameter requires version 1.18 of the Docker Remote API or greater on
	// your container instance. To check the Docker Remote API version on your
	// container instance, log in to your container instance and run the following
	// command: sudo docker version | grep "Server API version"
	//
	// The Amazon ECS container agent running on a container instance must register
	// the logging drivers available on that instance with the
	// ECS_AVAILABLE_LOGGING_DRIVERS environment variable before containers placed on
	// that instance can use these log configuration options. For more information, see
	// [Amazon ECS container agent configuration]in the Amazon Elastic Container Service Developer Guide.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Configure logging drivers]: https://docs.docker.com/engine/admin/logging/overview/
	// [Amazon ECS container agent configuration]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	// [LogConfiguration]: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-containerproperties-logconfiguration.html
	LogConfiguration *LogConfiguration

	// The name of the Amazon CloudWatch Logs log stream that's associated with the
	// container. The log group for Batch jobs is /aws/batch/job . Each container
	// attempt receives a log stream name when they reach the RUNNING status.
	LogStreamName *string

	// For jobs running on Amazon EC2 resources that didn't specify memory
	// requirements using resourceRequirements , the number of MiB of memory reserved
	// for the job. For other jobs, including all run on Fargate resources, see
	// resourceRequirements .
	Memory *int32

	// The mount points for data volumes in your container.
	MountPoints []MountPoint

	// The network configuration for jobs that are running on Fargate resources. Jobs
	// that are running on Amazon EC2 resources must not specify this parameter.
	NetworkConfiguration *NetworkConfiguration

	// The network interfaces that are associated with the job.
	NetworkInterfaces []NetworkInterface

	// When this parameter is true, the container is given elevated permissions on the
	// host container instance (similar to the root user). The default value is false .
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources
	// and shouldn't be provided, or specified as false .
	Privileged *bool

	// When this parameter is true, the container is given read-only access to its
	// root file system. This parameter maps to ReadonlyRootfs in the [Create a container] section of the [Docker Remote API]
	// and the --read-only option to [docker run]docker run .
	//
	// [docker run]: https://docs.docker.com/engine/reference/commandline/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	ReadonlyRootFilesystem *bool

	// A short (255 max characters) human-readable string to provide additional
	// details for a running or stopped container.
	Reason *string

	// The private repository authentication credentials to use.
	RepositoryCredentials *RepositoryCredentials

	// The type and amount of resources to assign to a container. The supported
	// resources include GPU , MEMORY , and VCPU .
	ResourceRequirements []ResourceRequirement

	// An object that represents the compute environment architecture for Batch jobs
	// on Fargate.
	RuntimePlatform *RuntimePlatform

	// The secrets to pass to the container. For more information, see [Specifying sensitive data] in the Batch
	// User Guide.
	//
	// [Specifying sensitive data]: https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data.html
	Secrets []Secret

	// The Amazon Resource Name (ARN) of the Amazon ECS task that's associated with
	// the container job. Each container attempt receives a task ARN when they reach
	// the STARTING status.
	TaskArn *string

	// A list of ulimit values to set in the container. This parameter maps to Ulimits
	// in the [Create a container]section of the [Docker Remote API] and the --ulimit option to [docker run].
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Ulimits []Ulimit

	// The user name to use inside the container. This parameter maps to User in the [Create a container]
	// section of the [Docker Remote API]and the --user option to [docker run].
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	User *string

	// The number of vCPUs reserved for the container. For jobs that run on Amazon EC2
	// resources, you can specify the vCPU requirement for the job using
	// resourceRequirements , but you can't specify the vCPU requirements in both the
	// vcpus and resourceRequirements object. This parameter maps to CpuShares in the [Create a container]
	// section of the [Docker Remote API]and the --cpu-shares option to [docker run]. Each vCPU is equivalent to
	// 1,024 CPU shares. You must specify at least one vCPU. This is required but can
	// be specified in several places. It must be specified for each node at least
	// once.
	//
	// This parameter isn't applicable to jobs that run on Fargate resources. For jobs
	// that run on Fargate resources, you must specify the vCPU requirement for the job
	// using resourceRequirements .
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Vcpus *int32

	// A list of volumes that are associated with the job.
	Volumes []Volume

	noSmithyDocumentSerde
}

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

func (v *ContainerDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Command != nil {
		serializeStringList(s, schemas.ContainerDetail_command, v.Command)
	}
	if v.ContainerInstanceArn != nil {
		s.WriteString(schemas.ContainerDetail_containerInstanceArn, *v.ContainerInstanceArn)
	}
	if v.EnableExecuteCommand != nil {
		s.WriteBool(schemas.ContainerDetail_enableExecuteCommand, *v.EnableExecuteCommand)
	}
	if v.Environment != nil {
		serializeEnvironmentVariables(s, schemas.ContainerDetail_environment, v.Environment)
	}
	if v.EphemeralStorage != nil {
		s.WriteStruct(schemas.ContainerDetail_ephemeralStorage)
		v.EphemeralStorage.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ExecutionRoleArn != nil {
		s.WriteString(schemas.ContainerDetail_executionRoleArn, *v.ExecutionRoleArn)
	}
	if v.ExitCode != nil {
		s.WriteInt32(schemas.ContainerDetail_exitCode, *v.ExitCode)
	}
	if v.FargatePlatformConfiguration != nil {
		s.WriteStruct(schemas.ContainerDetail_fargatePlatformConfiguration)
		v.FargatePlatformConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Image != nil {
		s.WriteString(schemas.ContainerDetail_image, *v.Image)
	}
	if v.InstanceType != nil {
		s.WriteString(schemas.ContainerDetail_instanceType, *v.InstanceType)
	}
	if v.JobRoleArn != nil {
		s.WriteString(schemas.ContainerDetail_jobRoleArn, *v.JobRoleArn)
	}
	if v.LinuxParameters != nil {
		s.WriteStruct(schemas.ContainerDetail_linuxParameters)
		v.LinuxParameters.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LogConfiguration != nil {
		s.WriteStruct(schemas.ContainerDetail_logConfiguration)
		v.LogConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LogStreamName != nil {
		s.WriteString(schemas.ContainerDetail_logStreamName, *v.LogStreamName)
	}
	if v.Memory != nil {
		s.WriteInt32(schemas.ContainerDetail_memory, *v.Memory)
	}
	if v.MountPoints != nil {
		serializeMountPoints(s, schemas.ContainerDetail_mountPoints, v.MountPoints)
	}
	if v.NetworkConfiguration != nil {
		s.WriteStruct(schemas.ContainerDetail_networkConfiguration)
		v.NetworkConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.NetworkInterfaces != nil {
		serializeNetworkInterfaceList(s, schemas.ContainerDetail_networkInterfaces, v.NetworkInterfaces)
	}
	if v.Privileged != nil {
		s.WriteBool(schemas.ContainerDetail_privileged, *v.Privileged)
	}
	if v.ReadonlyRootFilesystem != nil {
		s.WriteBool(schemas.ContainerDetail_readonlyRootFilesystem, *v.ReadonlyRootFilesystem)
	}
	if v.Reason != nil {
		s.WriteString(schemas.ContainerDetail_reason, *v.Reason)
	}
	if v.RepositoryCredentials != nil {
		s.WriteStruct(schemas.ContainerDetail_repositoryCredentials)
		v.RepositoryCredentials.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ResourceRequirements != nil {
		serializeResourceRequirements(s, schemas.ContainerDetail_resourceRequirements, v.ResourceRequirements)
	}
	if v.RuntimePlatform != nil {
		s.WriteStruct(schemas.ContainerDetail_runtimePlatform)
		v.RuntimePlatform.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Secrets != nil {
		serializeSecretList(s, schemas.ContainerDetail_secrets, v.Secrets)
	}
	if v.TaskArn != nil {
		s.WriteString(schemas.ContainerDetail_taskArn, *v.TaskArn)
	}
	if v.Ulimits != nil {
		serializeUlimits(s, schemas.ContainerDetail_ulimits, v.Ulimits)
	}
	if v.User != nil {
		s.WriteString(schemas.ContainerDetail_user, *v.User)
	}
	if v.Vcpus != nil {
		s.WriteInt32(schemas.ContainerDetail_vcpus, *v.Vcpus)
	}
	if v.Volumes != nil {
		serializeVolumes(s, schemas.ContainerDetail_volumes, v.Volumes)
	}
}
func (v *ContainerDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ContainerDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.ContainerDetail_command:
			return deserializeStringList(d, schemas.ContainerDetail_command, &v.Command)
		case schemas.ContainerDetail_containerInstanceArn:
			v.ContainerInstanceArn = new(string)
			return d.ReadString(schemas.ContainerDetail_containerInstanceArn, v.ContainerInstanceArn)
		case schemas.ContainerDetail_enableExecuteCommand:
			v.EnableExecuteCommand = new(bool)
			return d.ReadBool(schemas.ContainerDetail_enableExecuteCommand, v.EnableExecuteCommand)
		case schemas.ContainerDetail_environment:
			return deserializeEnvironmentVariables(d, schemas.ContainerDetail_environment, &v.Environment)
		case schemas.ContainerDetail_ephemeralStorage:
			v.EphemeralStorage = &EphemeralStorage{}
			return v.EphemeralStorage.Deserialize(d)
		case schemas.ContainerDetail_executionRoleArn:
			v.ExecutionRoleArn = new(string)
			return d.ReadString(schemas.ContainerDetail_executionRoleArn, v.ExecutionRoleArn)
		case schemas.ContainerDetail_exitCode:
			v.ExitCode = new(int32)
			return d.ReadInt32(schemas.ContainerDetail_exitCode, v.ExitCode)
		case schemas.ContainerDetail_fargatePlatformConfiguration:
			v.FargatePlatformConfiguration = &FargatePlatformConfiguration{}
			return v.FargatePlatformConfiguration.Deserialize(d)
		case schemas.ContainerDetail_image:
			v.Image = new(string)
			return d.ReadString(schemas.ContainerDetail_image, v.Image)
		case schemas.ContainerDetail_instanceType:
			v.InstanceType = new(string)
			return d.ReadString(schemas.ContainerDetail_instanceType, v.InstanceType)
		case schemas.ContainerDetail_jobRoleArn:
			v.JobRoleArn = new(string)
			return d.ReadString(schemas.ContainerDetail_jobRoleArn, v.JobRoleArn)
		case schemas.ContainerDetail_linuxParameters:
			v.LinuxParameters = &LinuxParameters{}
			return v.LinuxParameters.Deserialize(d)
		case schemas.ContainerDetail_logConfiguration:
			v.LogConfiguration = &LogConfiguration{}
			return v.LogConfiguration.Deserialize(d)
		case schemas.ContainerDetail_logStreamName:
			v.LogStreamName = new(string)
			return d.ReadString(schemas.ContainerDetail_logStreamName, v.LogStreamName)
		case schemas.ContainerDetail_memory:
			v.Memory = new(int32)
			return d.ReadInt32(schemas.ContainerDetail_memory, v.Memory)
		case schemas.ContainerDetail_mountPoints:
			return deserializeMountPoints(d, schemas.ContainerDetail_mountPoints, &v.MountPoints)
		case schemas.ContainerDetail_networkConfiguration:
			v.NetworkConfiguration = &NetworkConfiguration{}
			return v.NetworkConfiguration.Deserialize(d)
		case schemas.ContainerDetail_networkInterfaces:
			return deserializeNetworkInterfaceList(d, schemas.ContainerDetail_networkInterfaces, &v.NetworkInterfaces)
		case schemas.ContainerDetail_privileged:
			v.Privileged = new(bool)
			return d.ReadBool(schemas.ContainerDetail_privileged, v.Privileged)
		case schemas.ContainerDetail_readonlyRootFilesystem:
			v.ReadonlyRootFilesystem = new(bool)
			return d.ReadBool(schemas.ContainerDetail_readonlyRootFilesystem, v.ReadonlyRootFilesystem)
		case schemas.ContainerDetail_reason:
			v.Reason = new(string)
			return d.ReadString(schemas.ContainerDetail_reason, v.Reason)
		case schemas.ContainerDetail_repositoryCredentials:
			v.RepositoryCredentials = &RepositoryCredentials{}
			return v.RepositoryCredentials.Deserialize(d)
		case schemas.ContainerDetail_resourceRequirements:
			return deserializeResourceRequirements(d, schemas.ContainerDetail_resourceRequirements, &v.ResourceRequirements)
		case schemas.ContainerDetail_runtimePlatform:
			v.RuntimePlatform = &RuntimePlatform{}
			return v.RuntimePlatform.Deserialize(d)
		case schemas.ContainerDetail_secrets:
			return deserializeSecretList(d, schemas.ContainerDetail_secrets, &v.Secrets)
		case schemas.ContainerDetail_taskArn:
			v.TaskArn = new(string)
			return d.ReadString(schemas.ContainerDetail_taskArn, v.TaskArn)
		case schemas.ContainerDetail_ulimits:
			return deserializeUlimits(d, schemas.ContainerDetail_ulimits, &v.Ulimits)
		case schemas.ContainerDetail_user:
			v.User = new(string)
			return d.ReadString(schemas.ContainerDetail_user, v.User)
		case schemas.ContainerDetail_vcpus:
			v.Vcpus = new(int32)
			return d.ReadInt32(schemas.ContainerDetail_vcpus, v.Vcpus)
		case schemas.ContainerDetail_volumes:
			return deserializeVolumes(d, schemas.ContainerDetail_volumes, &v.Volumes)
		}
		return nil
	})
}

// The overrides that should be sent to a container.
//
// For information about using Batch overrides when you connect event sources to
// targets, see [BatchContainerOverrides].
//
// [BatchContainerOverrides]: https://docs.aws.amazon.com/eventbridge/latest/pipes-reference/API_BatchContainerOverrides.html
type ContainerOverrides struct {

	// The command to send to the container that overrides the default command from
	// the Docker image or the job definition.
	//
	// This parameter can't contain an empty string.
	Command []string

	// The environment variables to send to the container. You can add new environment
	// variables, which are added to the container at launch, or you can override the
	// existing environment variables from the Docker image or the job definition.
	//
	// Environment variables cannot start with " AWS_BATCH ". This naming convention is
	// reserved for variables that Batch sets.
	Environment []KeyValuePair

	// The instance type to use for a multi-node parallel job.
	//
	// This parameter isn't applicable to single-node container jobs or jobs that run
	// on Fargate resources, and shouldn't be provided.
	InstanceType *string

	// This parameter is deprecated, use resourceRequirements to override the memory
	// requirements specified in the job definition. It's not supported for jobs
	// running on Fargate resources. For jobs that run on Amazon EC2 resources, it
	// overrides the memory parameter set in the job definition, but doesn't override
	// any memory requirement that's specified in the resourceRequirements structure
	// in the job definition. To override memory requirements that are specified in the
	// resourceRequirements structure in the job definition, resourceRequirements must
	// be specified in the SubmitJob request, with type set to MEMORY and value set to
	// the new value. For more information, see [Can't override job definition resource requirements]in the Batch User Guide.
	//
	// [Can't override job definition resource requirements]: https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#override-resource-requirements
	//
	// Deprecated: This field is deprecated, use resourceRequirements instead.
	Memory *int32

	// The type and amount of resources to assign to a container. This overrides the
	// settings in the job definition. The supported resources include GPU , MEMORY ,
	// and VCPU .
	ResourceRequirements []ResourceRequirement

	// This parameter is deprecated, use resourceRequirements to override the vcpus
	// parameter that's set in the job definition. It's not supported for jobs running
	// on Fargate resources. For jobs that run on Amazon EC2 resources, it overrides
	// the vcpus parameter set in the job definition, but doesn't override any vCPU
	// requirement specified in the resourceRequirements structure in the job
	// definition. To override vCPU requirements that are specified in the
	// resourceRequirements structure in the job definition, resourceRequirements must
	// be specified in the SubmitJob request, with type set to VCPU and value set to
	// the new value. For more information, see [Can't override job definition resource requirements]in the Batch User Guide.
	//
	// [Can't override job definition resource requirements]: https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#override-resource-requirements
	//
	// Deprecated: This field is deprecated, use resourceRequirements instead.
	Vcpus *int32

	noSmithyDocumentSerde
}

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

func (v *ContainerOverrides) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Command != nil {
		serializeStringList(s, schemas.ContainerOverrides_command, v.Command)
	}
	if v.Environment != nil {
		serializeEnvironmentVariables(s, schemas.ContainerOverrides_environment, v.Environment)
	}
	if v.InstanceType != nil {
		s.WriteString(schemas.ContainerOverrides_instanceType, *v.InstanceType)
	}
	if v.Memory != nil {
		s.WriteInt32(schemas.ContainerOverrides_memory, *v.Memory)
	}
	if v.ResourceRequirements != nil {
		serializeResourceRequirements(s, schemas.ContainerOverrides_resourceRequirements, v.ResourceRequirements)
	}
	if v.Vcpus != nil {
		s.WriteInt32(schemas.ContainerOverrides_vcpus, *v.Vcpus)
	}
}
func (v *ContainerOverrides) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ContainerOverrides, func(s *smithy.Schema) error {
		switch s {
		case schemas.ContainerOverrides_command:
			return deserializeStringList(d, schemas.ContainerOverrides_command, &v.Command)
		case schemas.ContainerOverrides_environment:
			return deserializeEnvironmentVariables(d, schemas.ContainerOverrides_environment, &v.Environment)
		case schemas.ContainerOverrides_instanceType:
			v.InstanceType = new(string)
			return d.ReadString(schemas.ContainerOverrides_instanceType, v.InstanceType)
		case schemas.ContainerOverrides_memory:
			v.Memory = new(int32)
			return d.ReadInt32(schemas.ContainerOverrides_memory, v.Memory)
		case schemas.ContainerOverrides_resourceRequirements:
			return deserializeResourceRequirements(d, schemas.ContainerOverrides_resourceRequirements, &v.ResourceRequirements)
		case schemas.ContainerOverrides_vcpus:
			v.Vcpus = new(int32)
			return d.ReadInt32(schemas.ContainerOverrides_vcpus, v.Vcpus)
		}
		return nil
	})
}

// Container properties are used for Amazon ECS based job definitions. These
// properties to describe the container that's launched as part of a job.
type ContainerProperties struct {

	// The command that's passed to the container. This parameter maps to Cmd in the [Create a container]
	// section of the [Docker Remote API]and the COMMAND parameter to [docker run]. For more information, see [https://docs.docker.com/engine/reference/builder/#cmd].
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	// [https://docs.docker.com/engine/reference/builder/#cmd]: https://docs.docker.com/engine/reference/builder/#cmd
	Command []string

	// Determines whether execute command functionality is turned on for this task. If
	// true , execute command functionality is turned on all the containers in the task.
	EnableExecuteCommand *bool

	// The environment variables to pass to a container. This parameter maps to Env in
	// the [Create a container]section of the [Docker Remote API] and the --env option to [docker run].
	//
	// We don't recommend using plaintext environment variables for sensitive
	// information, such as credential data.
	//
	// Environment variables cannot start with " AWS_BATCH ". This naming convention is
	// reserved for variables that Batch sets.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Environment []KeyValuePair

	// The amount of ephemeral storage to allocate for the task. This parameter is
	// used to expand the total amount of ephemeral storage available, beyond the
	// default amount, for tasks hosted on Fargate.
	EphemeralStorage *EphemeralStorage

	// The Amazon Resource Name (ARN) of the execution role that Batch can assume. For
	// jobs that run on Fargate resources, you must provide an execution role. For more
	// information, see [Batch execution IAM role]in the Batch User Guide.
	//
	// [Batch execution IAM role]: https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html
	ExecutionRoleArn *string

	// The platform configuration for jobs that are running on Fargate resources. Jobs
	// that are running on Amazon EC2 resources must not specify this parameter.
	FargatePlatformConfiguration *FargatePlatformConfiguration

	// Required. The image used to start a container. This string is passed directly
	// to the Docker daemon. Images in the Docker Hub registry are available by
	// default. Other repositories are specified with repository-url/image:tag . It
	// can be 255 characters long. It can contain uppercase and lowercase letters,
	// numbers, hyphens (-), underscores (_), colons (:), periods (.), forward slashes
	// (/), and number signs (#). This parameter maps to Image in the [Create a container] section of the [Docker Remote API]
	// and the IMAGE parameter of [docker run].
	//
	// Docker image architecture must match the processor architecture of the compute
	// resources that they're scheduled on. For example, ARM-based Docker images can
	// only run on ARM-based compute resources.
	//
	//   - Images in Amazon ECR Public repositories use the full
	//   registry/repository[:tag] or registry/repository[@digest] naming conventions.
	//   For example, public.ecr.aws/registry_alias/my-web-app:latest .
	//
	//   - Images in Amazon ECR repositories use the full registry and repository URI
	//   (for example, 123456789012.dkr.ecr..amazonaws.com/ ).
	//
	//   - Images in official repositories on Docker Hub use a single name (for
	//   example, ubuntu or mongo ).
	//
	//   - Images in other repositories on Docker Hub are qualified with an
	//   organization name (for example, amazon/amazon-ecs-agent ).
	//
	//   - Images in other online repositories are qualified further by a domain name
	//   (for example, quay.io/assemblyline/ubuntu ).
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Image *string

	// The instance type to use for a multi-node parallel job. All node groups in a
	// multi-node parallel job must use the same instance type.
	//
	// This parameter isn't applicable to single-node container jobs or jobs that run
	// on Fargate resources, and shouldn't be provided.
	InstanceType *string

	// The Amazon Resource Name (ARN) of the IAM role that the container can assume
	// for Amazon Web Services permissions. For more information, see [IAM roles for tasks]in the Amazon
	// Elastic Container Service Developer Guide.
	//
	// [IAM roles for tasks]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html
	JobRoleArn *string

	// Linux-specific modifications that are applied to the container, such as details
	// for device mappings.
	LinuxParameters *LinuxParameters

	// The log configuration specification for the container.
	//
	// This parameter maps to LogConfig in the [Create a container] section of the [Docker Remote API] and the --log-driver
	// option to [docker run]. By default, containers use the same logging driver that the Docker
	// daemon uses. However the container might use a different logging driver than the
	// Docker daemon by specifying a log driver with this parameter in the container
	// definition. To use a different logging driver for a container, the log system
	// must be configured properly on the container instance (or on a different log
	// server for remote logging options). For more information on the options for
	// different supported log drivers, see [Configure logging drivers]in the Docker documentation.
	//
	// Batch currently supports a subset of the logging drivers available to the
	// Docker daemon (shown in the [LogConfiguration]data type).
	//
	// This parameter requires version 1.18 of the Docker Remote API or greater on
	// your container instance. To check the Docker Remote API version on your
	// container instance, log in to your container instance and run the following
	// command: sudo docker version | grep "Server API version"
	//
	// The Amazon ECS container agent running on a container instance must register
	// the logging drivers available on that instance with the
	// ECS_AVAILABLE_LOGGING_DRIVERS environment variable before containers placed on
	// that instance can use these log configuration options. For more information, see
	// [Amazon ECS container agent configuration]in the Amazon Elastic Container Service Developer Guide.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Configure logging drivers]: https://docs.docker.com/engine/admin/logging/overview/
	// [Amazon ECS container agent configuration]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	// [LogConfiguration]: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-containerproperties-logconfiguration.html
	LogConfiguration *LogConfiguration

	// This parameter is deprecated, use resourceRequirements to specify the memory
	// requirements for the job definition. It's not supported for jobs running on
	// Fargate resources. For jobs that run on Amazon EC2 resources, it specifies the
	// memory hard limit (in MiB) for a container. If your container attempts to exceed
	// the specified number, it's terminated. You must specify at least 4 MiB of memory
	// for a job using this parameter. The memory hard limit can be specified in
	// several places. It must be specified for each node at least once.
	//
	// Deprecated: This field is deprecated, use resourceRequirements instead.
	Memory *int32

	// The mount points for data volumes in your container. This parameter maps to
	// Volumes in the [Create a container] section of the [Docker Remote API] and the --volume option to [docker run].
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	MountPoints []MountPoint

	// The network configuration for jobs that are running on Fargate resources. Jobs
	// that are running on Amazon EC2 resources must not specify this parameter.
	NetworkConfiguration *NetworkConfiguration

	// When this parameter is true, the container is given elevated permissions on the
	// host container instance (similar to the root user). This parameter maps to
	// Privileged in the [Create a container] section of the [Docker Remote API] and the --privileged option to [docker run]. The default
	// value is false.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources
	// and shouldn't be provided, or specified as false.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Privileged *bool

	// When this parameter is true, the container is given read-only access to its
	// root file system. This parameter maps to ReadonlyRootfs in the [Create a container] section of the [Docker Remote API]
	// and the --read-only option to docker run .
	//
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	ReadonlyRootFilesystem *bool

	// The private repository authentication credentials to use.
	RepositoryCredentials *RepositoryCredentials

	// The type and amount of resources to assign to a container. The supported
	// resources include GPU , MEMORY , and VCPU .
	ResourceRequirements []ResourceRequirement

	// An object that represents the compute environment architecture for Batch jobs
	// on Fargate.
	RuntimePlatform *RuntimePlatform

	// The secrets for the container. For more information, see [Specifying sensitive data] in the Batch User
	// Guide.
	//
	// [Specifying sensitive data]: https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data.html
	Secrets []Secret

	// A list of ulimits to set in the container. This parameter maps to Ulimits in
	// the [Create a container]section of the [Docker Remote API] and the --ulimit option to [docker run].
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources
	// and shouldn't be provided.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Ulimits []Ulimit

	// The user name to use inside the container. This parameter maps to User in the [Create a container]
	// section of the [Docker Remote API]and the --user option to [docker run].
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	User *string

	// This parameter is deprecated, use resourceRequirements to specify the vCPU
	// requirements for the job definition. It's not supported for jobs running on
	// Fargate resources. For jobs running on Amazon EC2 resources, it specifies the
	// number of vCPUs reserved for the job.
	//
	// Each vCPU is equivalent to 1,024 CPU shares. This parameter maps to CpuShares
	// in the [Create a container]section of the [Docker Remote API] and the --cpu-shares option to [docker run]. The number of vCPUs
	// must be specified but can be specified in several places. You must specify it at
	// least once for each node.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	//
	// Deprecated: This field is deprecated, use resourceRequirements instead.
	Vcpus *int32

	// A list of data volumes used in a job.
	Volumes []Volume

	noSmithyDocumentSerde
}

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

func (v *ContainerProperties) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Command != nil {
		serializeStringList(s, schemas.ContainerProperties_command, v.Command)
	}
	if v.EnableExecuteCommand != nil {
		s.WriteBool(schemas.ContainerProperties_enableExecuteCommand, *v.EnableExecuteCommand)
	}
	if v.Environment != nil {
		serializeEnvironmentVariables(s, schemas.ContainerProperties_environment, v.Environment)
	}
	if v.EphemeralStorage != nil {
		s.WriteStruct(schemas.ContainerProperties_ephemeralStorage)
		v.EphemeralStorage.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ExecutionRoleArn != nil {
		s.WriteString(schemas.ContainerProperties_executionRoleArn, *v.ExecutionRoleArn)
	}
	if v.FargatePlatformConfiguration != nil {
		s.WriteStruct(schemas.ContainerProperties_fargatePlatformConfiguration)
		v.FargatePlatformConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Image != nil {
		s.WriteString(schemas.ContainerProperties_image, *v.Image)
	}
	if v.InstanceType != nil {
		s.WriteString(schemas.ContainerProperties_instanceType, *v.InstanceType)
	}
	if v.JobRoleArn != nil {
		s.WriteString(schemas.ContainerProperties_jobRoleArn, *v.JobRoleArn)
	}
	if v.LinuxParameters != nil {
		s.WriteStruct(schemas.ContainerProperties_linuxParameters)
		v.LinuxParameters.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LogConfiguration != nil {
		s.WriteStruct(schemas.ContainerProperties_logConfiguration)
		v.LogConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Memory != nil {
		s.WriteInt32(schemas.ContainerProperties_memory, *v.Memory)
	}
	if v.MountPoints != nil {
		serializeMountPoints(s, schemas.ContainerProperties_mountPoints, v.MountPoints)
	}
	if v.NetworkConfiguration != nil {
		s.WriteStruct(schemas.ContainerProperties_networkConfiguration)
		v.NetworkConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Privileged != nil {
		s.WriteBool(schemas.ContainerProperties_privileged, *v.Privileged)
	}
	if v.ReadonlyRootFilesystem != nil {
		s.WriteBool(schemas.ContainerProperties_readonlyRootFilesystem, *v.ReadonlyRootFilesystem)
	}
	if v.RepositoryCredentials != nil {
		s.WriteStruct(schemas.ContainerProperties_repositoryCredentials)
		v.RepositoryCredentials.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ResourceRequirements != nil {
		serializeResourceRequirements(s, schemas.ContainerProperties_resourceRequirements, v.ResourceRequirements)
	}
	if v.RuntimePlatform != nil {
		s.WriteStruct(schemas.ContainerProperties_runtimePlatform)
		v.RuntimePlatform.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Secrets != nil {
		serializeSecretList(s, schemas.ContainerProperties_secrets, v.Secrets)
	}
	if v.Ulimits != nil {
		serializeUlimits(s, schemas.ContainerProperties_ulimits, v.Ulimits)
	}
	if v.User != nil {
		s.WriteString(schemas.ContainerProperties_user, *v.User)
	}
	if v.Vcpus != nil {
		s.WriteInt32(schemas.ContainerProperties_vcpus, *v.Vcpus)
	}
	if v.Volumes != nil {
		serializeVolumes(s, schemas.ContainerProperties_volumes, v.Volumes)
	}
}
func (v *ContainerProperties) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ContainerProperties, func(s *smithy.Schema) error {
		switch s {
		case schemas.ContainerProperties_command:
			return deserializeStringList(d, schemas.ContainerProperties_command, &v.Command)
		case schemas.ContainerProperties_enableExecuteCommand:
			v.EnableExecuteCommand = new(bool)
			return d.ReadBool(schemas.ContainerProperties_enableExecuteCommand, v.EnableExecuteCommand)
		case schemas.ContainerProperties_environment:
			return deserializeEnvironmentVariables(d, schemas.ContainerProperties_environment, &v.Environment)
		case schemas.ContainerProperties_ephemeralStorage:
			v.EphemeralStorage = &EphemeralStorage{}
			return v.EphemeralStorage.Deserialize(d)
		case schemas.ContainerProperties_executionRoleArn:
			v.ExecutionRoleArn = new(string)
			return d.ReadString(schemas.ContainerProperties_executionRoleArn, v.ExecutionRoleArn)
		case schemas.ContainerProperties_fargatePlatformConfiguration:
			v.FargatePlatformConfiguration = &FargatePlatformConfiguration{}
			return v.FargatePlatformConfiguration.Deserialize(d)
		case schemas.ContainerProperties_image:
			v.Image = new(string)
			return d.ReadString(schemas.ContainerProperties_image, v.Image)
		case schemas.ContainerProperties_instanceType:
			v.InstanceType = new(string)
			return d.ReadString(schemas.ContainerProperties_instanceType, v.InstanceType)
		case schemas.ContainerProperties_jobRoleArn:
			v.JobRoleArn = new(string)
			return d.ReadString(schemas.ContainerProperties_jobRoleArn, v.JobRoleArn)
		case schemas.ContainerProperties_linuxParameters:
			v.LinuxParameters = &LinuxParameters{}
			return v.LinuxParameters.Deserialize(d)
		case schemas.ContainerProperties_logConfiguration:
			v.LogConfiguration = &LogConfiguration{}
			return v.LogConfiguration.Deserialize(d)
		case schemas.ContainerProperties_memory:
			v.Memory = new(int32)
			return d.ReadInt32(schemas.ContainerProperties_memory, v.Memory)
		case schemas.ContainerProperties_mountPoints:
			return deserializeMountPoints(d, schemas.ContainerProperties_mountPoints, &v.MountPoints)
		case schemas.ContainerProperties_networkConfiguration:
			v.NetworkConfiguration = &NetworkConfiguration{}
			return v.NetworkConfiguration.Deserialize(d)
		case schemas.ContainerProperties_privileged:
			v.Privileged = new(bool)
			return d.ReadBool(schemas.ContainerProperties_privileged, v.Privileged)
		case schemas.ContainerProperties_readonlyRootFilesystem:
			v.ReadonlyRootFilesystem = new(bool)
			return d.ReadBool(schemas.ContainerProperties_readonlyRootFilesystem, v.ReadonlyRootFilesystem)
		case schemas.ContainerProperties_repositoryCredentials:
			v.RepositoryCredentials = &RepositoryCredentials{}
			return v.RepositoryCredentials.Deserialize(d)
		case schemas.ContainerProperties_resourceRequirements:
			return deserializeResourceRequirements(d, schemas.ContainerProperties_resourceRequirements, &v.ResourceRequirements)
		case schemas.ContainerProperties_runtimePlatform:
			v.RuntimePlatform = &RuntimePlatform{}
			return v.RuntimePlatform.Deserialize(d)
		case schemas.ContainerProperties_secrets:
			return deserializeSecretList(d, schemas.ContainerProperties_secrets, &v.Secrets)
		case schemas.ContainerProperties_ulimits:
			return deserializeUlimits(d, schemas.ContainerProperties_ulimits, &v.Ulimits)
		case schemas.ContainerProperties_user:
			v.User = new(string)
			return d.ReadString(schemas.ContainerProperties_user, v.User)
		case schemas.ContainerProperties_vcpus:
			v.Vcpus = new(int32)
			return d.ReadInt32(schemas.ContainerProperties_vcpus, v.Vcpus)
		case schemas.ContainerProperties_volumes:
			return deserializeVolumes(d, schemas.ContainerProperties_volumes, &v.Volumes)
		}
		return nil
	})
}

// An object that represents summary details of a container within a job.
type ContainerSummary struct {

	// The exit code to return upon completion.
	ExitCode *int32

	// A short (255 max characters) human-readable string to provide additional
	// details for a running or stopped container.
	Reason *string

	noSmithyDocumentSerde
}

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

func (v *ContainerSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ExitCode != nil {
		s.WriteInt32(schemas.ContainerSummary_exitCode, *v.ExitCode)
	}
	if v.Reason != nil {
		s.WriteString(schemas.ContainerSummary_reason, *v.Reason)
	}
}
func (v *ContainerSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ContainerSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.ContainerSummary_exitCode:
			v.ExitCode = new(int32)
			return d.ReadInt32(schemas.ContainerSummary_exitCode, v.ExitCode)
		case schemas.ContainerSummary_reason:
			v.Reason = new(string)
			return d.ReadString(schemas.ContainerSummary_reason, v.Reason)
		}
		return nil
	})
}

// An object that represents a container instance host device.
//
// This object isn't applicable to jobs that are running on Fargate resources and
// shouldn't be provided.
type Device struct {

	// The path for the device on the host container instance.
	//
	// This member is required.
	HostPath *string

	// The path inside the container that's used to expose the host device. By
	// default, the hostPath value is used.
	ContainerPath *string

	// The explicit permissions to provide to the container for the device. By
	// default, the container has permissions for read , write , and mknod for the
	// device.
	Permissions []DeviceCgroupPermission

	noSmithyDocumentSerde
}

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

func (v *Device) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerPath != nil {
		s.WriteString(schemas.Device_containerPath, *v.ContainerPath)
	}
	if v.HostPath != nil {
		s.WriteString(schemas.Device_hostPath, *v.HostPath)
	}
	if v.Permissions != nil {
		serializeDeviceCgroupPermissions(s, schemas.Device_permissions, v.Permissions)
	}
}
func (v *Device) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Device, func(s *smithy.Schema) error {
		switch s {
		case schemas.Device_containerPath:
			v.ContainerPath = new(string)
			return d.ReadString(schemas.Device_containerPath, v.ContainerPath)
		case schemas.Device_hostPath:
			v.HostPath = new(string)
			return d.ReadString(schemas.Device_hostPath, v.HostPath)
		case schemas.Device_permissions:
			return deserializeDeviceCgroupPermissions(d, schemas.Device_permissions, &v.Permissions)
		}
		return nil
	})
}

// Provides information used to select Amazon Machine Images (AMIs) for instances
// in the compute environment. If Ec2Configuration isn't specified, the default is
// ECS_AL2023 ([Amazon ECS-optimized Amazon Linux 2023] ) for EC2 (ECS) compute environments and EKS_AL2023 ([Amazon EKS-optimized Amazon Linux 2023 AMI] ) for EKS
// compute environments.
//
// This object isn't applicable to jobs that are running on Fargate resources.
//
// [Amazon ECS-optimized Amazon Linux 2023]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html
// [Amazon EKS-optimized Amazon Linux 2023 AMI]: https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
type Ec2Configuration struct {

	// The image type to match with the instance type to select an AMI. The supported
	// values are different for ECS and EKS resources.
	//
	// ECS If the imageIdOverride parameter isn't specified, then a recent [Amazon ECS-optimized Amazon Linux 2023 AMI] ( ECS_AL2023
	// ) is used. If a new image type is specified in an update, but neither an imageId
	// nor a imageIdOverride parameter is specified, then the latest Amazon ECS
	// optimized AMI for that image type that's supported by Batch is used.
	//
	// Amazon Web Services is ending support for Amazon ECS Amazon Linux 2-optimized
	// and accelerated AMIs on June 30, 2026. On January 12, 2026, Batch changed the
	// default AMI for new Amazon ECS compute environments from Amazon Linux 2 to
	// Amazon Linux 2023. Effective June 30, 2026, Batch will block creation of new
	// Amazon ECS compute environments using Batch-provided Amazon Linux 2 AMIs. We
	// strongly recommend migrating your existing Batch Amazon ECS compute environments
	// to Amazon Linux 2023 prior to June 30, 2026. For more information on upgrading
	// from AL2 to AL2023, see [How to migrate from ECS AL2 to ECS AL2023]in the Batch User Guide.
	//
	// ECS_AL2 [Amazon Linux 2]: Used for non-GPU instance families.
	//
	// ECS_AL2_NVIDIA [Amazon Linux 2 (GPU)]: Used for GPU instance families (for example P4 and G4 ) and non
	// Amazon Web Services Graviton-based instance types.
	//
	// ECS_AL2023 [Amazon Linux 2023]: Default for all non-GPU instance families.
	//
	// Amazon Linux 2023 does not support A1 instances.
	//
	// ECS_AL2023_NVIDIA [Amazon Linux 2023 (GPU)]: Default for all GPU instance families and can be used for
	// all non Amazon Web Services Graviton-based instance types.
	//
	// ECS_AL2023_NVIDIA doesn't support p3 and g3 instance types.
	//
	// EKS If the imageIdOverride parameter isn't specified, then a recent [Amazon EKS-optimized Amazon Linux 2023 AMI] ( EKS_AL2023
	// ) is used. If a new image type is specified in an update, but neither an imageId
	// nor a imageIdOverride parameter is specified, then the latest Amazon EKS
	// optimized AMI for that image type that Batch supports is used.
	//
	// Amazon Linux 2023 AMIs are the default on Batch for Amazon EKS.
	//
	// Amazon Web Services ended support for Amazon EKS AL2-optimized and
	// AL2-accelerated AMIs on November 26, 2025. Batch Amazon EKS compute environments
	// using Amazon Linux 2 will no longer receive software updates, security patches,
	// or bug fixes from Amazon Web Services. We recommend migrating to Amazon Linux
	// 2023. For more information on upgrading from AL2 to AL2023, see [How to upgrade from EKS AL2 to EKS AL2023]in the Batch
	// User Guide.
	//
	// EKS_AL2 [Amazon Linux 2]: Used for non-GPU instance families.
	//
	// EKS_AL2_NVIDIA [Amazon Linux 2 (accelerated)]: Used for GPU instance families (for example, P4 and G4 ) and
	// can be used for all non Amazon Web Services Graviton-based instance types.
	//
	// EKS_AL2023 [Amazon Linux 2023]: Default for non-GPU instance families.
	//
	// Amazon Linux 2023 does not support A1 instances.
	//
	// EKS_AL2023_NVIDIA [Amazon Linux 2023 (accelerated)]: Default for GPU instance families and can be used for all
	// non Amazon Web Services Graviton-based instance types.
	//
	// [Amazon Linux 2023]: https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// [Amazon ECS-optimized Amazon Linux 2023 AMI]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html
	// [How to upgrade from EKS AL2 to EKS AL2023]: https://docs.aws.amazon.com/batch/latest/userguide/eks-migration-2023.html
	// [Amazon Linux 2 (GPU)]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#gpuami
	// [Amazon Linux 2023 (GPU)]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#gpuami
	// [Amazon Linux 2023 (accelerated)]: https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// [Amazon Linux 2 (accelerated)]: https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// [Amazon Linux 2]: https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// [How to migrate from ECS AL2 to ECS AL2023]: https://docs.aws.amazon.com/batch/latest/userguide/ecs-migration-2023.html
	// [Amazon EKS-optimized Amazon Linux 2023 AMI]: https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	//
	// This member is required.
	ImageType *string

	// The status of the Batch-provided default AMIs associated with the imageType .
	//
	// The field only appears after the compute environment has begun scaling
	// instances using the imageType . The field is not present when an image is
	// specified in ComputeResources.imageId (deprecated), the default launch
	// template, or Ec2Configuration.imageIdOverride . The field is also not present
	// when the compute environment has a launch template override.
	//
	// For more information on image selection, see [AMI selection order].
	//
	// This field is read-only and only appears in the [DescribeComputeEnvironments] response.
	//
	//   - LATEST − Using the most recent AMI supported
	//
	//   - UPDATE_AVAILABLE − An updated AMI is available
	//
	//   - If a compute environment has multiple AMIs for the imageType and any one AMI
	//   has UPDATE_AVAILABLE , the status shows UPDATE_AVAILABLE .
	//
	//   - For compute environments that use BEST_FIT as their allocation strategy, you
	//   can perform a [blue/green update]to update the AMI.
	//
	//   - For all other compute environments, you can perform an [AMI version update]to update the AMI to
	//   the latest version.
	//
	// [blue/green update]: https://docs.aws.amazon.com/batch/latest/userguide/blue-green-updates.html
	// [AMI selection order]: https://docs.aws.amazon.com/batch/latest/userguide/ami-selection-order.html
	// [AMI version update]: https://docs.aws.amazon.com/batch/latest/userguide/managing-ami-versions.html#updating-ami-versions
	// [DescribeComputeEnvironments]: https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeComputeEnvironments.html
	BatchImageStatus *string

	// The AMI ID used for instances launched in the compute environment that match
	// the image type. This setting overrides the imageId set in the computeResource
	// object.
	//
	// The AMI that you choose for a compute environment must match the architecture
	// of the instance types that you intend to use for that compute environment. For
	// example, if your compute environment uses A1 instance types, the compute
	// resource AMI that you choose must support ARM instances. Amazon ECS vends both
	// x86 and ARM versions of the Amazon ECS-optimized Amazon Linux 2023 AMI. For more
	// information, see [Amazon ECS-optimized Amazon Linux 2023 AMI]in the Amazon Elastic Container Service Developer Guide.
	//
	// [Amazon ECS-optimized Amazon Linux 2023 AMI]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux-variants.html
	ImageIdOverride *string

	// The Kubernetes version for the compute environment. If you don't specify a
	// value, the latest version that Batch supports is used.
	ImageKubernetesVersion *string

	noSmithyDocumentSerde
}

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

func (v *Ec2Configuration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.BatchImageStatus != nil {
		s.WriteString(schemas.Ec2Configuration_batchImageStatus, *v.BatchImageStatus)
	}
	if v.ImageIdOverride != nil {
		s.WriteString(schemas.Ec2Configuration_imageIdOverride, *v.ImageIdOverride)
	}
	if v.ImageKubernetesVersion != nil {
		s.WriteString(schemas.Ec2Configuration_imageKubernetesVersion, *v.ImageKubernetesVersion)
	}
	if v.ImageType != nil {
		s.WriteString(schemas.Ec2Configuration_imageType, *v.ImageType)
	}
}
func (v *Ec2Configuration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Ec2Configuration, func(s *smithy.Schema) error {
		switch s {
		case schemas.Ec2Configuration_batchImageStatus:
			v.BatchImageStatus = new(string)
			return d.ReadString(schemas.Ec2Configuration_batchImageStatus, v.BatchImageStatus)
		case schemas.Ec2Configuration_imageIdOverride:
			v.ImageIdOverride = new(string)
			return d.ReadString(schemas.Ec2Configuration_imageIdOverride, v.ImageIdOverride)
		case schemas.Ec2Configuration_imageKubernetesVersion:
			v.ImageKubernetesVersion = new(string)
			return d.ReadString(schemas.Ec2Configuration_imageKubernetesVersion, v.ImageKubernetesVersion)
		case schemas.Ec2Configuration_imageType:
			v.ImageType = new(string)
			return d.ReadString(schemas.Ec2Configuration_imageType, v.ImageType)
		}
		return nil
	})
}

// An object that contains the properties for the Amazon ECS resources of a job.
type EcsProperties struct {

	// An object that contains the properties for the Amazon ECS task definition of a
	// job.
	//
	// This object is currently limited to one task element. However, the task element
	// can run up to 10 containers.
	//
	// This member is required.
	TaskProperties []EcsTaskProperties

	noSmithyDocumentSerde
}

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

func (v *EcsProperties) SerializeMembers(s smithy.ShapeSerializer) {
	if v.TaskProperties != nil {
		serializeListEcsTaskProperties(s, schemas.EcsProperties_taskProperties, v.TaskProperties)
	}
}
func (v *EcsProperties) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EcsProperties, func(s *smithy.Schema) error {
		switch s {
		case schemas.EcsProperties_taskProperties:
			return deserializeListEcsTaskProperties(d, schemas.EcsProperties_taskProperties, &v.TaskProperties)
		}
		return nil
	})
}

// An object that contains the details for the Amazon ECS resources of a job.
type EcsPropertiesDetail struct {

	// The properties for the Amazon ECS task definition of a job.
	TaskProperties []EcsTaskDetails

	noSmithyDocumentSerde
}

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

func (v *EcsPropertiesDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.TaskProperties != nil {
		serializeListEcsTaskDetails(s, schemas.EcsPropertiesDetail_taskProperties, v.TaskProperties)
	}
}
func (v *EcsPropertiesDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EcsPropertiesDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.EcsPropertiesDetail_taskProperties:
			return deserializeListEcsTaskDetails(d, schemas.EcsPropertiesDetail_taskProperties, &v.TaskProperties)
		}
		return nil
	})
}

// An object that contains overrides for the Amazon ECS task definition of a job.
type EcsPropertiesOverride struct {

	// The overrides for the Amazon ECS task definition of a job.
	//
	// This object is currently limited to one element.
	TaskProperties []TaskPropertiesOverride

	noSmithyDocumentSerde
}

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

func (v *EcsPropertiesOverride) SerializeMembers(s smithy.ShapeSerializer) {
	if v.TaskProperties != nil {
		serializeListTaskPropertiesOverride(s, schemas.EcsPropertiesOverride_taskProperties, v.TaskProperties)
	}
}
func (v *EcsPropertiesOverride) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EcsPropertiesOverride, func(s *smithy.Schema) error {
		switch s {
		case schemas.EcsPropertiesOverride_taskProperties:
			return deserializeListTaskPropertiesOverride(d, schemas.EcsPropertiesOverride_taskProperties, &v.TaskProperties)
		}
		return nil
	})
}

// The Amazon ECS settings for a compute environment, including the CloudWatch
// Container Insights mode. Use this structure with CreateComputeEnvironment and
// UpdateComputeEnvironment .
type EcsSettings struct {

	// Specifies the CloudWatch Container Insights mode for the compute environment.
	// Valid values are:
	//
	// ENABLED Turns on standard Container Insights, which collects CPU, memory, disk,
	// and network utilization metrics for the compute environment.
	//
	// ENHANCED Turns on enhanced Container Insights, which collects the standard
	// metrics along with additional per-task observability metrics.
	//
	// DISABLED Turns off Container Insights for the compute environment.
	//
	// If you don't specify a value, the default is DISABLED . For more information,
	// see [Container Insights]in the Batch User Guide.
	//
	// [Container Insights]: https://docs.aws.amazon.com/batch/latest/userguide/cloudwatch-container-insights.html
	ContainerInsights ContainerInsights

	noSmithyDocumentSerde
}

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

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

// The details of a task definition that describes the container and volume
// definitions of an Amazon ECS task.
type EcsTaskDetails struct {

	// The Amazon Resource Name (ARN) of the container instance that hosts the task.
	ContainerInstanceArn *string

	// A list of containers that are included in the taskProperties list.
	Containers []TaskContainerDetails

	// Determines whether execute command functionality is turned on for this task. If
	// true , execute command functionality is turned on all the containers in the task.
	EnableExecuteCommand *bool

	// The amount of ephemeral storage allocated for the task.
	EphemeralStorage *EphemeralStorage

	// The Amazon Resource Name (ARN) of the execution role that Batch can assume. For
	// more information, see [Batch execution IAM role]in the Batch User Guide.
	//
	// [Batch execution IAM role]: https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html
	ExecutionRoleArn *string

	// The IPC resource namespace to use for the containers in the task. The valid
	// values are host , task , or none . For more information see ipcMode in [EcsTaskProperties].
	//
	// [EcsTaskProperties]: https://docs.aws.amazon.com/batch/latest/APIReference/API_EcsTaskProperties.html
	IpcMode *string

	// The network configuration for jobs that are running on Fargate resources. Jobs
	// that are running on Amazon EC2 resources must not specify this parameter.
	NetworkConfiguration *NetworkConfiguration

	// The network mode configured for the task. This field is populated for jobs
	// running on Amazon ECS Managed Instances ( MANAGED_INSTANCES platform
	// capability) and always returns host .
	NetworkMode *string

	// The process namespace to use for the containers in the task. The valid values
	// are host , or task . For more information see pidMode in [EcsTaskProperties].
	//
	// [EcsTaskProperties]: https://docs.aws.amazon.com/batch/latest/APIReference/API_EcsTaskProperties.html
	PidMode *string

	// The Fargate platform version where the jobs are running.
	PlatformVersion *string

	// An object that represents the compute environment architecture for Batch jobs
	// on Fargate or Amazon ECS Managed Instances. Contains the operating system family
	// and CPU architecture of the task.
	RuntimePlatform *RuntimePlatform

	// The ARN of the Amazon ECS task.
	TaskArn *string

	// The Amazon Resource Name (ARN) of the IAM role that the container can assume
	// for Amazon Web Services permissions. For more information, see [IAM roles for tasks]in the Amazon
	// Elastic Container Service Developer Guide.
	//
	// This is object is comparable to [ContainerProperties:jobRoleArn].
	//
	// [ContainerProperties:jobRoleArn]: https://docs.aws.amazon.com/batch/latest/APIReference/API_ContainerProperties.html
	// [IAM roles for tasks]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html
	TaskRoleArn *string

	// A list of data volumes used in a job.
	Volumes []Volume

	noSmithyDocumentSerde
}

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

func (v *EcsTaskDetails) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerInstanceArn != nil {
		s.WriteString(schemas.EcsTaskDetails_containerInstanceArn, *v.ContainerInstanceArn)
	}
	if v.Containers != nil {
		serializeListTaskContainerDetails(s, schemas.EcsTaskDetails_containers, v.Containers)
	}
	if v.EnableExecuteCommand != nil {
		s.WriteBool(schemas.EcsTaskDetails_enableExecuteCommand, *v.EnableExecuteCommand)
	}
	if v.EphemeralStorage != nil {
		s.WriteStruct(schemas.EcsTaskDetails_ephemeralStorage)
		v.EphemeralStorage.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ExecutionRoleArn != nil {
		s.WriteString(schemas.EcsTaskDetails_executionRoleArn, *v.ExecutionRoleArn)
	}
	if v.IpcMode != nil {
		s.WriteString(schemas.EcsTaskDetails_ipcMode, *v.IpcMode)
	}
	if v.NetworkConfiguration != nil {
		s.WriteStruct(schemas.EcsTaskDetails_networkConfiguration)
		v.NetworkConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.NetworkMode != nil {
		s.WriteString(schemas.EcsTaskDetails_networkMode, *v.NetworkMode)
	}
	if v.PidMode != nil {
		s.WriteString(schemas.EcsTaskDetails_pidMode, *v.PidMode)
	}
	if v.PlatformVersion != nil {
		s.WriteString(schemas.EcsTaskDetails_platformVersion, *v.PlatformVersion)
	}
	if v.RuntimePlatform != nil {
		s.WriteStruct(schemas.EcsTaskDetails_runtimePlatform)
		v.RuntimePlatform.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.TaskArn != nil {
		s.WriteString(schemas.EcsTaskDetails_taskArn, *v.TaskArn)
	}
	if v.TaskRoleArn != nil {
		s.WriteString(schemas.EcsTaskDetails_taskRoleArn, *v.TaskRoleArn)
	}
	if v.Volumes != nil {
		serializeVolumes(s, schemas.EcsTaskDetails_volumes, v.Volumes)
	}
}
func (v *EcsTaskDetails) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EcsTaskDetails, func(s *smithy.Schema) error {
		switch s {
		case schemas.EcsTaskDetails_containerInstanceArn:
			v.ContainerInstanceArn = new(string)
			return d.ReadString(schemas.EcsTaskDetails_containerInstanceArn, v.ContainerInstanceArn)
		case schemas.EcsTaskDetails_containers:
			return deserializeListTaskContainerDetails(d, schemas.EcsTaskDetails_containers, &v.Containers)
		case schemas.EcsTaskDetails_enableExecuteCommand:
			v.EnableExecuteCommand = new(bool)
			return d.ReadBool(schemas.EcsTaskDetails_enableExecuteCommand, v.EnableExecuteCommand)
		case schemas.EcsTaskDetails_ephemeralStorage:
			v.EphemeralStorage = &EphemeralStorage{}
			return v.EphemeralStorage.Deserialize(d)
		case schemas.EcsTaskDetails_executionRoleArn:
			v.ExecutionRoleArn = new(string)
			return d.ReadString(schemas.EcsTaskDetails_executionRoleArn, v.ExecutionRoleArn)
		case schemas.EcsTaskDetails_ipcMode:
			v.IpcMode = new(string)
			return d.ReadString(schemas.EcsTaskDetails_ipcMode, v.IpcMode)
		case schemas.EcsTaskDetails_networkConfiguration:
			v.NetworkConfiguration = &NetworkConfiguration{}
			return v.NetworkConfiguration.Deserialize(d)
		case schemas.EcsTaskDetails_networkMode:
			v.NetworkMode = new(string)
			return d.ReadString(schemas.EcsTaskDetails_networkMode, v.NetworkMode)
		case schemas.EcsTaskDetails_pidMode:
			v.PidMode = new(string)
			return d.ReadString(schemas.EcsTaskDetails_pidMode, v.PidMode)
		case schemas.EcsTaskDetails_platformVersion:
			v.PlatformVersion = new(string)
			return d.ReadString(schemas.EcsTaskDetails_platformVersion, v.PlatformVersion)
		case schemas.EcsTaskDetails_runtimePlatform:
			v.RuntimePlatform = &RuntimePlatform{}
			return v.RuntimePlatform.Deserialize(d)
		case schemas.EcsTaskDetails_taskArn:
			v.TaskArn = new(string)
			return d.ReadString(schemas.EcsTaskDetails_taskArn, v.TaskArn)
		case schemas.EcsTaskDetails_taskRoleArn:
			v.TaskRoleArn = new(string)
			return d.ReadString(schemas.EcsTaskDetails_taskRoleArn, v.TaskRoleArn)
		case schemas.EcsTaskDetails_volumes:
			return deserializeVolumes(d, schemas.EcsTaskDetails_volumes, &v.Volumes)
		}
		return nil
	})
}

// The properties for a task definition that describes the container and volume
// definitions of an Amazon ECS task. You can specify which Docker images to use,
// the required resources, and other configurations related to launching the task
// definition through an Amazon ECS service or task.
type EcsTaskProperties struct {

	// This object is a list of containers.
	//
	// This member is required.
	Containers []TaskContainerProperties

	// Determines whether execute command functionality is turned on for this task. If
	// true , execute command functionality is turned on all the containers in the task.
	EnableExecuteCommand *bool

	// The amount of ephemeral storage to allocate for the task. This parameter is
	// used to expand the total amount of ephemeral storage available, beyond the
	// default amount, for tasks hosted on Fargate.
	EphemeralStorage *EphemeralStorage

	// The Amazon Resource Name (ARN) of the execution role that Batch can assume. For
	// jobs that run on Fargate resources, you must provide an execution role. For more
	// information, see [Batch execution IAM role]in the Batch User Guide.
	//
	// [Batch execution IAM role]: https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html
	ExecutionRoleArn *string

	// The IPC resource namespace to use for the containers in the task. The valid
	// values are host , task , or none .
	//
	// If host is specified, all containers within the tasks that specified the host
	// IPC mode on the same container instance share the same IPC resources with the
	// host Amazon EC2 instance.
	//
	// If task is specified, all containers within the specified task share the same
	// IPC resources.
	//
	// If none is specified, the IPC resources within the containers of a task are
	// private, and are not shared with other containers in a task or on the container
	// instance.
	//
	// If no value is specified, then the IPC resource namespace sharing depends on
	// the Docker daemon setting on the container instance. For more information, see [IPC settings]
	// in the Docker run reference.
	//
	// This parameter is not supported for jobs that run on Fargate resources.
	//
	// [IPC settings]: https://docs.docker.com/engine/reference/run/#ipc-settings---ipc
	IpcMode *string

	// The network configuration for jobs that are running on Fargate resources. Jobs
	// that are running on Amazon EC2 resources or Amazon ECS Managed Instances must
	// not specify this parameter.
	NetworkConfiguration *NetworkConfiguration

	// The network mode to use for the task. Valid values: host . When not specified,
	// the default is host .
	//
	// With host mode, the container shares the host instance's network stack
	// directly. When running tasks that use the host network mode, do not run
	// containers using the root user (UID 0). Running as root grants unrestricted
	// access to host resources and increases the attack surface.
	//
	// This parameter only applies to jobs running on Amazon ECS Managed Instances (
	// MANAGED_INSTANCES platform capability). It cannot be specified for Fargate or
	// Amazon EC2 platform job definitions.
	NetworkMode *string

	// The process namespace to use for the containers in the task. The valid values
	// are host or task . For example, monitoring sidecars might need pidMode to
	// access information about other containers running in the same task.
	//
	// If host is specified, all containers within the tasks that specified the host
	// PID mode on the same container instance share the process namespace with the
	// host Amazon EC2 instance.
	//
	// If task is specified, all containers within the specified task share the same
	// process namespace.
	//
	// If no value is specified, the default is a private namespace for each
	// container. For more information, see [PID settings]in the Docker run reference.
	//
	// [PID settings]: https://docs.docker.com/engine/reference/run/#pid-settings---pid
	PidMode *string

	// The Fargate platform version where the jobs are running. A platform version is
	// specified only for jobs that are running on Fargate resources. If one isn't
	// specified, the LATEST platform version is used by default. This uses a recent,
	// approved version of the Fargate platform for compute resources. For more
	// information, see [Fargate platform versions]in the Amazon Elastic Container Service Developer Guide.
	//
	// [Fargate platform versions]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html
	PlatformVersion *string

	// An object that represents the compute environment architecture for Batch jobs
	// on Fargate or Amazon ECS Managed Instances. Use this to specify the operating
	// system family ( operatingSystemFamily ) and CPU architecture ( cpuArchitecture ).
	//
	// For Amazon ECS Managed Instances, the valid value for operatingSystemFamily is
	// LINUX (default). The valid values for cpuArchitecture are X86_64 and ARM64 .
	RuntimePlatform *RuntimePlatform

	// The Amazon Resource Name (ARN) that's associated with the Amazon ECS task.
	//
	// This is object is comparable to [ContainerProperties:jobRoleArn].
	//
	// [ContainerProperties:jobRoleArn]: https://docs.aws.amazon.com/batch/latest/APIReference/API_ContainerProperties.html
	TaskRoleArn *string

	// A list of volumes that are associated with the job.
	Volumes []Volume

	noSmithyDocumentSerde
}

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

func (v *EcsTaskProperties) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Containers != nil {
		serializeListTaskContainerProperties(s, schemas.EcsTaskProperties_containers, v.Containers)
	}
	if v.EnableExecuteCommand != nil {
		s.WriteBool(schemas.EcsTaskProperties_enableExecuteCommand, *v.EnableExecuteCommand)
	}
	if v.EphemeralStorage != nil {
		s.WriteStruct(schemas.EcsTaskProperties_ephemeralStorage)
		v.EphemeralStorage.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ExecutionRoleArn != nil {
		s.WriteString(schemas.EcsTaskProperties_executionRoleArn, *v.ExecutionRoleArn)
	}
	if v.IpcMode != nil {
		s.WriteString(schemas.EcsTaskProperties_ipcMode, *v.IpcMode)
	}
	if v.NetworkConfiguration != nil {
		s.WriteStruct(schemas.EcsTaskProperties_networkConfiguration)
		v.NetworkConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.NetworkMode != nil {
		s.WriteString(schemas.EcsTaskProperties_networkMode, *v.NetworkMode)
	}
	if v.PidMode != nil {
		s.WriteString(schemas.EcsTaskProperties_pidMode, *v.PidMode)
	}
	if v.PlatformVersion != nil {
		s.WriteString(schemas.EcsTaskProperties_platformVersion, *v.PlatformVersion)
	}
	if v.RuntimePlatform != nil {
		s.WriteStruct(schemas.EcsTaskProperties_runtimePlatform)
		v.RuntimePlatform.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.TaskRoleArn != nil {
		s.WriteString(schemas.EcsTaskProperties_taskRoleArn, *v.TaskRoleArn)
	}
	if v.Volumes != nil {
		serializeVolumes(s, schemas.EcsTaskProperties_volumes, v.Volumes)
	}
}
func (v *EcsTaskProperties) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EcsTaskProperties, func(s *smithy.Schema) error {
		switch s {
		case schemas.EcsTaskProperties_containers:
			return deserializeListTaskContainerProperties(d, schemas.EcsTaskProperties_containers, &v.Containers)
		case schemas.EcsTaskProperties_enableExecuteCommand:
			v.EnableExecuteCommand = new(bool)
			return d.ReadBool(schemas.EcsTaskProperties_enableExecuteCommand, v.EnableExecuteCommand)
		case schemas.EcsTaskProperties_ephemeralStorage:
			v.EphemeralStorage = &EphemeralStorage{}
			return v.EphemeralStorage.Deserialize(d)
		case schemas.EcsTaskProperties_executionRoleArn:
			v.ExecutionRoleArn = new(string)
			return d.ReadString(schemas.EcsTaskProperties_executionRoleArn, v.ExecutionRoleArn)
		case schemas.EcsTaskProperties_ipcMode:
			v.IpcMode = new(string)
			return d.ReadString(schemas.EcsTaskProperties_ipcMode, v.IpcMode)
		case schemas.EcsTaskProperties_networkConfiguration:
			v.NetworkConfiguration = &NetworkConfiguration{}
			return v.NetworkConfiguration.Deserialize(d)
		case schemas.EcsTaskProperties_networkMode:
			v.NetworkMode = new(string)
			return d.ReadString(schemas.EcsTaskProperties_networkMode, v.NetworkMode)
		case schemas.EcsTaskProperties_pidMode:
			v.PidMode = new(string)
			return d.ReadString(schemas.EcsTaskProperties_pidMode, v.PidMode)
		case schemas.EcsTaskProperties_platformVersion:
			v.PlatformVersion = new(string)
			return d.ReadString(schemas.EcsTaskProperties_platformVersion, v.PlatformVersion)
		case schemas.EcsTaskProperties_runtimePlatform:
			v.RuntimePlatform = &RuntimePlatform{}
			return v.RuntimePlatform.Deserialize(d)
		case schemas.EcsTaskProperties_taskRoleArn:
			v.TaskRoleArn = new(string)
			return d.ReadString(schemas.EcsTaskProperties_taskRoleArn, v.TaskRoleArn)
		case schemas.EcsTaskProperties_volumes:
			return deserializeVolumes(d, schemas.EcsTaskProperties_volumes, &v.Volumes)
		}
		return nil
	})
}

// The authorization configuration details for the Amazon EFS file system.
type EFSAuthorizationConfig struct {

	// The Amazon EFS access point ID to use. If an access point is specified, the
	// root directory value specified in the EFSVolumeConfiguration must either be
	// omitted or set to / which enforces the path set on the EFS access point. If an
	// access point is used, transit encryption must be enabled in the
	// EFSVolumeConfiguration . For more information, see [Working with Amazon EFS access points] in the Amazon Elastic File
	// System User Guide.
	//
	// [Working with Amazon EFS access points]: https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html
	AccessPointId *string

	// Whether or not to use the Batch job IAM role defined in a job definition when
	// mounting the Amazon EFS file system. If enabled, transit encryption must be
	// enabled in the EFSVolumeConfiguration . If this parameter is omitted, the
	// default value of DISABLED is used. For more information, see [Using Amazon EFS access points] in the Batch User
	// Guide. EFS IAM authorization requires that TransitEncryption be ENABLED and
	// that a JobRoleArn is specified.
	//
	// [Using Amazon EFS access points]: https://docs.aws.amazon.com/batch/latest/userguide/efs-volumes.html#efs-volume-accesspoints
	Iam EFSAuthorizationConfigIAM

	noSmithyDocumentSerde
}

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

func (v *EFSAuthorizationConfig) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccessPointId != nil {
		s.WriteString(schemas.EFSAuthorizationConfig_accessPointId, *v.AccessPointId)
	}
	if v.Iam != "" {
		s.WriteString(schemas.EFSAuthorizationConfig_iam, string(v.Iam))
	}
}
func (v *EFSAuthorizationConfig) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EFSAuthorizationConfig, func(s *smithy.Schema) error {
		switch s {
		case schemas.EFSAuthorizationConfig_accessPointId:
			v.AccessPointId = new(string)
			return d.ReadString(schemas.EFSAuthorizationConfig_accessPointId, v.AccessPointId)
		case schemas.EFSAuthorizationConfig_iam:
			var ev string
			if err := d.ReadString(schemas.EFSAuthorizationConfig_iam, &ev); err != nil {
				return err
			}
			v.Iam = EFSAuthorizationConfigIAM(ev)
			return nil
		}
		return nil
	})
}

// This is used when you're using an Amazon Elastic File System file system for
// job storage. For more information, see [Amazon EFS Volumes]in the Batch User Guide.
//
// [Amazon EFS Volumes]: https://docs.aws.amazon.com/batch/latest/userguide/efs-volumes.html
type EFSVolumeConfiguration struct {

	// The Amazon EFS file system ID to use.
	//
	// This member is required.
	FileSystemId *string

	// The authorization configuration details for the Amazon EFS file system.
	AuthorizationConfig *EFSAuthorizationConfig

	// The directory within the Amazon EFS file system to mount as the root directory
	// inside the host. If this parameter is omitted, the root of the Amazon EFS volume
	// is used instead. Specifying / has the same effect as omitting this parameter.
	// The maximum length is 4,096 characters.
	//
	// If an EFS access point is specified in the authorizationConfig , the root
	// directory parameter must either be omitted or set to / , which enforces the path
	// set on the Amazon EFS access point.
	RootDirectory *string

	// Determines whether to enable encryption for Amazon EFS data in transit between
	// the Amazon ECS host and the Amazon EFS server. Transit encryption must be
	// enabled if Amazon EFS IAM authorization is used. If this parameter is omitted,
	// the default value of DISABLED is used. For more information, see [Encrypting data in transit] in the Amazon
	// Elastic File System User Guide.
	//
	// [Encrypting data in transit]: https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html
	TransitEncryption EFSTransitEncryption

	// The port to use when sending encrypted data between the Amazon ECS host and the
	// Amazon EFS server. If you don't specify a transit encryption port, it uses the
	// port selection strategy that the Amazon EFS mount helper uses. The value must be
	// between 0 and 65,535. For more information, see [EFS mount helper]in the Amazon Elastic File
	// System User Guide.
	//
	// [EFS mount helper]: https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html
	TransitEncryptionPort *int32

	noSmithyDocumentSerde
}

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

func (v *EFSVolumeConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AuthorizationConfig != nil {
		s.WriteStruct(schemas.EFSVolumeConfiguration_authorizationConfig)
		v.AuthorizationConfig.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.FileSystemId != nil {
		s.WriteString(schemas.EFSVolumeConfiguration_fileSystemId, *v.FileSystemId)
	}
	if v.RootDirectory != nil {
		s.WriteString(schemas.EFSVolumeConfiguration_rootDirectory, *v.RootDirectory)
	}
	if v.TransitEncryption != "" {
		s.WriteString(schemas.EFSVolumeConfiguration_transitEncryption, string(v.TransitEncryption))
	}
	if v.TransitEncryptionPort != nil {
		s.WriteInt32(schemas.EFSVolumeConfiguration_transitEncryptionPort, *v.TransitEncryptionPort)
	}
}
func (v *EFSVolumeConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EFSVolumeConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.EFSVolumeConfiguration_authorizationConfig:
			v.AuthorizationConfig = &EFSAuthorizationConfig{}
			return v.AuthorizationConfig.Deserialize(d)
		case schemas.EFSVolumeConfiguration_fileSystemId:
			v.FileSystemId = new(string)
			return d.ReadString(schemas.EFSVolumeConfiguration_fileSystemId, v.FileSystemId)
		case schemas.EFSVolumeConfiguration_rootDirectory:
			v.RootDirectory = new(string)
			return d.ReadString(schemas.EFSVolumeConfiguration_rootDirectory, v.RootDirectory)
		case schemas.EFSVolumeConfiguration_transitEncryption:
			var ev string
			if err := d.ReadString(schemas.EFSVolumeConfiguration_transitEncryption, &ev); err != nil {
				return err
			}
			v.TransitEncryption = EFSTransitEncryption(ev)
			return nil
		case schemas.EFSVolumeConfiguration_transitEncryptionPort:
			v.TransitEncryptionPort = new(int32)
			return d.ReadInt32(schemas.EFSVolumeConfiguration_transitEncryptionPort, v.TransitEncryptionPort)
		}
		return nil
	})
}

// Configures whether Batch manages an Amazon EKS access entry on the cluster for
// the compute environment. For information on how the fields interact with the
// cluster's authenticationMode and with other compute environments that share the
// cluster, see [Amazon EKS access entry authentication]in the Batch User Guide.
//
// Setting desiredState=ENABLED on a single compute environment does not guarantee
// that Batch creates an access entry, and setting desiredState=DISABLED on a
// single compute environment does not guarantee that Batch deletes one. Batch
// compares the desiredState across all compute environments that target the same
// cluster. The Batch-managed access entry is created only when all compute
// environments have desiredState=ENABLED , and deleted only when all have
// desiredState=DISABLED . If you have multiple compute environments on the same
// cluster, set desiredState consistently across all of them to avoid uncertainty.
// For more information, see [Reconciling desiredState across compute environments]in the Batch User Guide.
//
// [Reconciling desiredState across compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/eks-access-entries.html#eks-access-entries-reconciliation
// [Amazon EKS access entry authentication]: https://docs.aws.amazon.com/batch/latest/userguide/eks-access-entries.html
type EksAccessEntry struct {

	// The desired access entry state for the compute environment. Valid values:
	//
	// ENABLED Batch manages an access entry on the cluster for the compute
	// environment.
	//
	// DISABLED Batch deletes the Batch-managed access entry for the cluster. This
	// value is rejected if the cluster's authenticationMode is API , because such a
	// cluster doesn't support the aws-auth ConfigMap.
	//
	// INHERIT_FROM_CLUSTER Batch defers to the cluster's current access entry status .
	// On a cluster whose authentication mode is API , Batch creates and manages an
	// access entry. On a cluster whose authentication mode is API_AND_CONFIG_MAP or
	// CONFIG_MAP , Batch neither adds nor removes an access entry.
	//
	// This member is required.
	DesiredState EksAccessEntryDesiredState

	// The observed state of the access entry on the cluster. ACTIVE means that an
	// access entry for the compute environment exists on the cluster and takes
	// precedence over the aws-auth ConfigMap. INACTIVE means that no Batch-managed
	// access entry is present. This is a read-only field returned by
	// DescribeComputeEnvironments .
	Status EksAccessEntryStatus

	noSmithyDocumentSerde
}

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

func (v *EksAccessEntry) SerializeMembers(s smithy.ShapeSerializer) {
	if v.DesiredState != "" {
		s.WriteString(schemas.EksAccessEntry_desiredState, string(v.DesiredState))
	}
	if v.Status != "" {
		s.WriteString(schemas.EksAccessEntry_status, string(v.Status))
	}
}
func (v *EksAccessEntry) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksAccessEntry, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksAccessEntry_desiredState:
			var ev string
			if err := d.ReadString(schemas.EksAccessEntry_desiredState, &ev); err != nil {
				return err
			}
			v.DesiredState = EksAccessEntryDesiredState(ev)
			return nil
		case schemas.EksAccessEntry_status:
			var ev string
			if err := d.ReadString(schemas.EksAccessEntry_status, &ev); err != nil {
				return err
			}
			v.Status = EksAccessEntryStatus(ev)
			return nil
		}
		return nil
	})
}

// An object that represents the details for an attempt for a job attempt that an
// Amazon EKS container runs.
type EksAttemptContainerDetail struct {

	// The ID for the container.
	ContainerID *string

	// The exit code returned for the job attempt. A non-zero exit code is considered
	// failed.
	ExitCode *int32

	// The name of a container.
	Name *string

	// A short (255 max characters) human-readable string to provide additional
	// details for a running or stopped container.
	Reason *string

	noSmithyDocumentSerde
}

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

func (v *EksAttemptContainerDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerID != nil {
		s.WriteString(schemas.EksAttemptContainerDetail_containerID, *v.ContainerID)
	}
	if v.ExitCode != nil {
		s.WriteInt32(schemas.EksAttemptContainerDetail_exitCode, *v.ExitCode)
	}
	if v.Name != nil {
		s.WriteString(schemas.EksAttemptContainerDetail_name, *v.Name)
	}
	if v.Reason != nil {
		s.WriteString(schemas.EksAttemptContainerDetail_reason, *v.Reason)
	}
}
func (v *EksAttemptContainerDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksAttemptContainerDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksAttemptContainerDetail_containerID:
			v.ContainerID = new(string)
			return d.ReadString(schemas.EksAttemptContainerDetail_containerID, v.ContainerID)
		case schemas.EksAttemptContainerDetail_exitCode:
			v.ExitCode = new(int32)
			return d.ReadInt32(schemas.EksAttemptContainerDetail_exitCode, v.ExitCode)
		case schemas.EksAttemptContainerDetail_name:
			v.Name = new(string)
			return d.ReadString(schemas.EksAttemptContainerDetail_name, v.Name)
		case schemas.EksAttemptContainerDetail_reason:
			v.Reason = new(string)
			return d.ReadString(schemas.EksAttemptContainerDetail_reason, v.Reason)
		}
		return nil
	})
}

// An object that represents the details of a job attempt for a job attempt by an
// Amazon EKS container.
type EksAttemptDetail struct {

	// The details for the final status of the containers for this job attempt.
	Containers []EksAttemptContainerDetail

	// The Amazon Resource Name (ARN) of the Amazon EKS cluster.
	EksClusterArn *string

	// The details for the init containers.
	InitContainers []EksAttemptContainerDetail

	// The name of the node for this job attempt.
	NodeName *string

	// The name of the pod for this job attempt.
	PodName *string

	// The namespace of the Amazon EKS cluster that the pod exists in.
	PodNamespace *string

	// The Unix timestamp (in milliseconds) for when the attempt was started (when the
	// attempt transitioned from the STARTING state to the RUNNING state).
	StartedAt *int64

	// A short, human-readable string to provide additional details for the current
	// status of the job attempt.
	StatusReason *string

	// The Unix timestamp (in milliseconds) for when the attempt was stopped. This
	// happens when the attempt transitioned from the RUNNING state to a terminal
	// state, such as SUCCEEDED or FAILED .
	StoppedAt *int64

	noSmithyDocumentSerde
}

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

func (v *EksAttemptDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Containers != nil {
		serializeEksAttemptContainerDetails(s, schemas.EksAttemptDetail_containers, v.Containers)
	}
	if v.EksClusterArn != nil {
		s.WriteString(schemas.EksAttemptDetail_eksClusterArn, *v.EksClusterArn)
	}
	if v.InitContainers != nil {
		serializeEksAttemptContainerDetails(s, schemas.EksAttemptDetail_initContainers, v.InitContainers)
	}
	if v.NodeName != nil {
		s.WriteString(schemas.EksAttemptDetail_nodeName, *v.NodeName)
	}
	if v.PodName != nil {
		s.WriteString(schemas.EksAttemptDetail_podName, *v.PodName)
	}
	if v.PodNamespace != nil {
		s.WriteString(schemas.EksAttemptDetail_podNamespace, *v.PodNamespace)
	}
	if v.StartedAt != nil {
		s.WriteInt64(schemas.EksAttemptDetail_startedAt, *v.StartedAt)
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.EksAttemptDetail_statusReason, *v.StatusReason)
	}
	if v.StoppedAt != nil {
		s.WriteInt64(schemas.EksAttemptDetail_stoppedAt, *v.StoppedAt)
	}
}
func (v *EksAttemptDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksAttemptDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksAttemptDetail_containers:
			return deserializeEksAttemptContainerDetails(d, schemas.EksAttemptDetail_containers, &v.Containers)
		case schemas.EksAttemptDetail_eksClusterArn:
			v.EksClusterArn = new(string)
			return d.ReadString(schemas.EksAttemptDetail_eksClusterArn, v.EksClusterArn)
		case schemas.EksAttemptDetail_initContainers:
			return deserializeEksAttemptContainerDetails(d, schemas.EksAttemptDetail_initContainers, &v.InitContainers)
		case schemas.EksAttemptDetail_nodeName:
			v.NodeName = new(string)
			return d.ReadString(schemas.EksAttemptDetail_nodeName, v.NodeName)
		case schemas.EksAttemptDetail_podName:
			v.PodName = new(string)
			return d.ReadString(schemas.EksAttemptDetail_podName, v.PodName)
		case schemas.EksAttemptDetail_podNamespace:
			v.PodNamespace = new(string)
			return d.ReadString(schemas.EksAttemptDetail_podNamespace, v.PodNamespace)
		case schemas.EksAttemptDetail_startedAt:
			v.StartedAt = new(int64)
			return d.ReadInt64(schemas.EksAttemptDetail_startedAt, v.StartedAt)
		case schemas.EksAttemptDetail_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.EksAttemptDetail_statusReason, v.StatusReason)
		case schemas.EksAttemptDetail_stoppedAt:
			v.StoppedAt = new(int64)
			return d.ReadInt64(schemas.EksAttemptDetail_stoppedAt, v.StoppedAt)
		}
		return nil
	})
}

// Configuration for the Amazon EKS cluster that supports the Batch compute
// environment. The cluster must exist before the compute environment can be
// created.
type EksConfiguration struct {

	// The Amazon Resource Name (ARN) of the Amazon EKS cluster. An example is
	// arn:aws:eks:us-east-1:123456789012:cluster/ClusterForBatch .
	//
	// This member is required.
	EksClusterArn *string

	// The namespace of the Amazon EKS cluster. Batch manages pods in this namespace.
	// The value can't left empty or null. It must be fewer than 64 characters long,
	// can't be set to default , can't start with " kube- ," and must match this
	// regular expression: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$ . For more information, see [Namespaces]
	// in the Kubernetes documentation.
	//
	// [Namespaces]: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
	//
	// This member is required.
	KubernetesNamespace *string

	// The Batch-managed Amazon EKS access entry for the compute environment. Set
	// desiredState to declare whether Batch manages an access entry on the cluster. In
	// a DescribeComputeEnvironments response, desiredState is the value that Batch
	// recorded for the compute environment and status is the observed state of the
	// access entry on the cluster. To change the access entry on an existing compute
	// environment, use [EksConfigurationUpdate.accessEntry]EksConfigurationUpdate.accessEntry .
	//
	// Whether the entry is provisioned on the cluster depends on the cluster's
	// authenticationMode and the desiredState recorded for each Batch compute
	// environment targeting the cluster. For more information, see [Amazon EKS access entry authentication]in the Batch User
	// Guide.
	//
	// If you don't specify this field, Batch doesn't record a desiredState for the
	// compute environment and DescribeComputeEnvironments doesn't return one. For the
	// purpose of provisioning the access entry, Batch behaves as it does for
	// INHERIT_FROM_CLUSTER .
	//
	// [EksConfigurationUpdate.accessEntry]: https://docs.aws.amazon.com/batch/latest/APIReference/API_EksConfigurationUpdate.html#Batch-Type-EksConfigurationUpdate-accessEntry
	// [Amazon EKS access entry authentication]: https://docs.aws.amazon.com/batch/latest/userguide/eks-access-entries.html
	AccessEntry *EksAccessEntry

	noSmithyDocumentSerde
}

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

func (v *EksConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccessEntry != nil {
		s.WriteStruct(schemas.EksConfiguration_accessEntry)
		v.AccessEntry.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EksClusterArn != nil {
		s.WriteString(schemas.EksConfiguration_eksClusterArn, *v.EksClusterArn)
	}
	if v.KubernetesNamespace != nil {
		s.WriteString(schemas.EksConfiguration_kubernetesNamespace, *v.KubernetesNamespace)
	}
}
func (v *EksConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksConfiguration_accessEntry:
			v.AccessEntry = &EksAccessEntry{}
			return v.AccessEntry.Deserialize(d)
		case schemas.EksConfiguration_eksClusterArn:
			v.EksClusterArn = new(string)
			return d.ReadString(schemas.EksConfiguration_eksClusterArn, v.EksClusterArn)
		case schemas.EksConfiguration_kubernetesNamespace:
			v.KubernetesNamespace = new(string)
			return d.ReadString(schemas.EksConfiguration_kubernetesNamespace, v.KubernetesNamespace)
		}
		return nil
	})
}

// An object that represents the attributes of an Batch compute environment's
// Amazon EKS configuration that can be updated. Currently accessEntry is the only
// attribute that you can change after the compute environment is created. For more
// information, see [Amazon EKS access entry authentication]in the Batch User Guide.
//
// [Amazon EKS access entry authentication]: https://docs.aws.amazon.com/batch/latest/userguide/eks-access-entries.html
type EksConfigurationUpdate struct {

	// The updated access entry configuration for the compute environment. Set
	// desiredState to declare whether Batch will manage an access entry on the
	// cluster. For the accepted values, see [EksAccessEntry]EksAccessEntry .
	//
	// [EksAccessEntry]: https://docs.aws.amazon.com/batch/latest/APIReference/API_EksAccessEntry.html
	AccessEntry *EksAccessEntry

	noSmithyDocumentSerde
}

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

func (v *EksConfigurationUpdate) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccessEntry != nil {
		s.WriteStruct(schemas.EksConfigurationUpdate_accessEntry)
		v.AccessEntry.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *EksConfigurationUpdate) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksConfigurationUpdate, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksConfigurationUpdate_accessEntry:
			v.AccessEntry = &EksAccessEntry{}
			return v.AccessEntry.Deserialize(d)
		}
		return nil
	})
}

// EKS container properties are used in job definitions for Amazon EKS based job
// definitions to describe the properties for a container node in the pod that's
// launched as part of a job. This can't be specified for Amazon ECS based job
// definitions.
type EksContainer struct {

	// The Docker image used to start the container.
	//
	// This member is required.
	Image *string

	// An array of arguments to the entrypoint. If this isn't specified, the CMD of
	// the container image is used. This corresponds to the args member in the [Entrypoint]
	// portion of the [Pod]in Kubernetes. Environment variable references are expanded
	// using the container's environment.
	//
	// If the referenced environment variable doesn't exist, the reference in the
	// command isn't changed. For example, if the reference is to " $(NAME1) " and the
	// NAME1 environment variable doesn't exist, the command string will remain "
	// $(NAME1) ." $$ is replaced with $ , and the resulting string isn't expanded. For
	// example, $$(VAR_NAME) is passed as $(VAR_NAME) whether or not the VAR_NAME
	// environment variable exists. For more information, see [Dockerfile reference: CMD]and [Define a command and arguments for a pod] in the Kubernetes
	// documentation.
	//
	// [Entrypoint]: https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint
	// [Pod]: https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/
	// [Dockerfile reference: CMD]: https://docs.docker.com/engine/reference/builder/#cmd
	// [Define a command and arguments for a pod]: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/
	Args []string

	// The entrypoint for the container. This isn't run within a shell. If this isn't
	// specified, the ENTRYPOINT of the container image is used. Environment variable
	// references are expanded using the container's environment.
	//
	// If the referenced environment variable doesn't exist, the reference in the
	// command isn't changed. For example, if the reference is to " $(NAME1) " and the
	// NAME1 environment variable doesn't exist, the command string will remain "
	// $(NAME1) ." $$ is replaced with $ and the resulting string isn't expanded. For
	// example, $$(VAR_NAME) will be passed as $(VAR_NAME) whether or not the VAR_NAME
	// environment variable exists. The entrypoint can't be updated. For more
	// information, see [ENTRYPOINT]in the Dockerfile reference and [Define a command and arguments for a container] and [Entrypoint] in the Kubernetes
	// documentation.
	//
	// [Define a command and arguments for a container]: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/
	// [Entrypoint]: https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint
	// [ENTRYPOINT]: https://docs.docker.com/engine/reference/builder/#entrypoint
	Command []string

	// The environment variables to pass to a container.
	//
	// Environment variables cannot start with " AWS_BATCH ". This naming convention is
	// reserved for variables that Batch sets.
	Env []EksContainerEnvironmentVariable

	// The image pull policy for the container. Supported values are Always ,
	// IfNotPresent , and Never . This parameter defaults to IfNotPresent . However, if
	// the :latest tag is specified, it defaults to Always . For more information, see [Updating images]
	// in the Kubernetes documentation.
	//
	// [Updating images]: https://kubernetes.io/docs/concepts/containers/images/#updating-images
	ImagePullPolicy *string

	// The name of the container. If the name isn't specified, the default name "
	// Default " is used. Each container in a pod must have a unique name.
	Name *string

	// The type and amount of resources to assign to a container. The supported
	// resources include memory , cpu , and nvidia.com/gpu . For more information, see [Resource management for pods and containers]
	// in the Kubernetes documentation.
	//
	// [Resource management for pods and containers]: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	Resources *EksContainerResourceRequirements

	// The security context for a job. For more information, see [Configure a security context for a pod or container] in the Kubernetes
	// documentation.
	//
	// [Configure a security context for a pod or container]: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
	SecurityContext *EksContainerSecurityContext

	// The volume mounts for the container. Batch supports emptyDir , hostPath , and
	// secret volume types. For more information about volumes and volume mounts in
	// Kubernetes, see [Volumes]in the Kubernetes documentation.
	//
	// [Volumes]: https://kubernetes.io/docs/concepts/storage/volumes/
	VolumeMounts []EksContainerVolumeMount

	noSmithyDocumentSerde
}

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

func (v *EksContainer) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Args != nil {
		serializeStringList(s, schemas.EksContainer_args, v.Args)
	}
	if v.Command != nil {
		serializeStringList(s, schemas.EksContainer_command, v.Command)
	}
	if v.Env != nil {
		serializeEksContainerEnvironmentVariables(s, schemas.EksContainer_env, v.Env)
	}
	if v.Image != nil {
		s.WriteString(schemas.EksContainer_image, *v.Image)
	}
	if v.ImagePullPolicy != nil {
		s.WriteString(schemas.EksContainer_imagePullPolicy, *v.ImagePullPolicy)
	}
	if v.Name != nil {
		s.WriteString(schemas.EksContainer_name, *v.Name)
	}
	if v.Resources != nil {
		s.WriteStruct(schemas.EksContainer_resources)
		v.Resources.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SecurityContext != nil {
		s.WriteStruct(schemas.EksContainer_securityContext)
		v.SecurityContext.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.VolumeMounts != nil {
		serializeEksContainerVolumeMounts(s, schemas.EksContainer_volumeMounts, v.VolumeMounts)
	}
}
func (v *EksContainer) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksContainer, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksContainer_args:
			return deserializeStringList(d, schemas.EksContainer_args, &v.Args)
		case schemas.EksContainer_command:
			return deserializeStringList(d, schemas.EksContainer_command, &v.Command)
		case schemas.EksContainer_env:
			return deserializeEksContainerEnvironmentVariables(d, schemas.EksContainer_env, &v.Env)
		case schemas.EksContainer_image:
			v.Image = new(string)
			return d.ReadString(schemas.EksContainer_image, v.Image)
		case schemas.EksContainer_imagePullPolicy:
			v.ImagePullPolicy = new(string)
			return d.ReadString(schemas.EksContainer_imagePullPolicy, v.ImagePullPolicy)
		case schemas.EksContainer_name:
			v.Name = new(string)
			return d.ReadString(schemas.EksContainer_name, v.Name)
		case schemas.EksContainer_resources:
			v.Resources = &EksContainerResourceRequirements{}
			return v.Resources.Deserialize(d)
		case schemas.EksContainer_securityContext:
			v.SecurityContext = &EksContainerSecurityContext{}
			return v.SecurityContext.Deserialize(d)
		case schemas.EksContainer_volumeMounts:
			return deserializeEksContainerVolumeMounts(d, schemas.EksContainer_volumeMounts, &v.VolumeMounts)
		}
		return nil
	})
}

// The details for container properties that are returned by DescribeJobs for jobs
// that use Amazon EKS.
type EksContainerDetail struct {

	// An array of arguments to the entrypoint. If this isn't specified, the CMD of
	// the container image is used. This corresponds to the args member in the [Entrypoint]
	// portion of the [Pod]in Kubernetes. Environment variable references are expanded
	// using the container's environment.
	//
	// If the referenced environment variable doesn't exist, the reference in the
	// command isn't changed. For example, if the reference is to " $(NAME1) " and the
	// NAME1 environment variable doesn't exist, the command string will remain "
	// $(NAME1) ". $$ is replaced with $ and the resulting string isn't expanded. For
	// example, $$(VAR_NAME) is passed as $(VAR_NAME) whether or not the VAR_NAME
	// environment variable exists. For more information, see [Dockerfile reference: CMD]and [Define a command and arguments for a pod] in the Kubernetes
	// documentation.
	//
	// [Entrypoint]: https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint
	// [Pod]: https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/
	// [Dockerfile reference: CMD]: https://docs.docker.com/engine/reference/builder/#cmd
	// [Define a command and arguments for a pod]: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/
	Args []string

	// The entrypoint for the container. For more information, see [Entrypoint] in the Kubernetes
	// documentation.
	//
	// [Entrypoint]: https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint
	Command []string

	// The environment variables to pass to a container.
	//
	// Environment variables cannot start with " AWS_BATCH ". This naming convention is
	// reserved for variables that Batch sets.
	Env []EksContainerEnvironmentVariable

	// The exit code returned for the job attempt. A non-zero exit code is considered
	// failed.
	ExitCode *int32

	// The Docker image used to start the container.
	Image *string

	// The image pull policy for the container. Supported values are Always ,
	// IfNotPresent , and Never . This parameter defaults to Always if the :latest tag
	// is specified, IfNotPresent otherwise. For more information, see [Updating images] in the
	// Kubernetes documentation.
	//
	// [Updating images]: https://kubernetes.io/docs/concepts/containers/images/#updating-images
	ImagePullPolicy *string

	// The name of the container. If the name isn't specified, the default name "
	// Default " is used. Each container in a pod must have a unique name.
	Name *string

	// A short human-readable string to provide additional details for a running or
	// stopped container. It can be up to 255 characters long.
	Reason *string

	// The type and amount of resources to assign to a container. The supported
	// resources include memory , cpu , and nvidia.com/gpu . For more information, see [Resource management for pods and containers]
	// in the Kubernetes documentation.
	//
	// [Resource management for pods and containers]: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	Resources *EksContainerResourceRequirements

	// The security context for a job. For more information, see [Configure a security context for a pod or container] in the Kubernetes
	// documentation.
	//
	// [Configure a security context for a pod or container]: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
	SecurityContext *EksContainerSecurityContext

	// The volume mounts for the container. Batch supports emptyDir , hostPath , and
	// secret volume types. For more information about volumes and volume mounts in
	// Kubernetes, see [Volumes]in the Kubernetes documentation.
	//
	// [Volumes]: https://kubernetes.io/docs/concepts/storage/volumes/
	VolumeMounts []EksContainerVolumeMount

	noSmithyDocumentSerde
}

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

func (v *EksContainerDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Args != nil {
		serializeStringList(s, schemas.EksContainerDetail_args, v.Args)
	}
	if v.Command != nil {
		serializeStringList(s, schemas.EksContainerDetail_command, v.Command)
	}
	if v.Env != nil {
		serializeEksContainerEnvironmentVariables(s, schemas.EksContainerDetail_env, v.Env)
	}
	if v.ExitCode != nil {
		s.WriteInt32(schemas.EksContainerDetail_exitCode, *v.ExitCode)
	}
	if v.Image != nil {
		s.WriteString(schemas.EksContainerDetail_image, *v.Image)
	}
	if v.ImagePullPolicy != nil {
		s.WriteString(schemas.EksContainerDetail_imagePullPolicy, *v.ImagePullPolicy)
	}
	if v.Name != nil {
		s.WriteString(schemas.EksContainerDetail_name, *v.Name)
	}
	if v.Reason != nil {
		s.WriteString(schemas.EksContainerDetail_reason, *v.Reason)
	}
	if v.Resources != nil {
		s.WriteStruct(schemas.EksContainerDetail_resources)
		v.Resources.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SecurityContext != nil {
		s.WriteStruct(schemas.EksContainerDetail_securityContext)
		v.SecurityContext.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.VolumeMounts != nil {
		serializeEksContainerVolumeMounts(s, schemas.EksContainerDetail_volumeMounts, v.VolumeMounts)
	}
}
func (v *EksContainerDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksContainerDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksContainerDetail_args:
			return deserializeStringList(d, schemas.EksContainerDetail_args, &v.Args)
		case schemas.EksContainerDetail_command:
			return deserializeStringList(d, schemas.EksContainerDetail_command, &v.Command)
		case schemas.EksContainerDetail_env:
			return deserializeEksContainerEnvironmentVariables(d, schemas.EksContainerDetail_env, &v.Env)
		case schemas.EksContainerDetail_exitCode:
			v.ExitCode = new(int32)
			return d.ReadInt32(schemas.EksContainerDetail_exitCode, v.ExitCode)
		case schemas.EksContainerDetail_image:
			v.Image = new(string)
			return d.ReadString(schemas.EksContainerDetail_image, v.Image)
		case schemas.EksContainerDetail_imagePullPolicy:
			v.ImagePullPolicy = new(string)
			return d.ReadString(schemas.EksContainerDetail_imagePullPolicy, v.ImagePullPolicy)
		case schemas.EksContainerDetail_name:
			v.Name = new(string)
			return d.ReadString(schemas.EksContainerDetail_name, v.Name)
		case schemas.EksContainerDetail_reason:
			v.Reason = new(string)
			return d.ReadString(schemas.EksContainerDetail_reason, v.Reason)
		case schemas.EksContainerDetail_resources:
			v.Resources = &EksContainerResourceRequirements{}
			return v.Resources.Deserialize(d)
		case schemas.EksContainerDetail_securityContext:
			v.SecurityContext = &EksContainerSecurityContext{}
			return v.SecurityContext.Deserialize(d)
		case schemas.EksContainerDetail_volumeMounts:
			return deserializeEksContainerVolumeMounts(d, schemas.EksContainerDetail_volumeMounts, &v.VolumeMounts)
		}
		return nil
	})
}

// An environment variable.
type EksContainerEnvironmentVariable struct {

	// The name of the environment variable.
	//
	// This member is required.
	Name *string

	// The value of the environment variable.
	Value *string

	noSmithyDocumentSerde
}

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

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

// Object representing any Kubernetes overrides to a job definition that's used in
// a [SubmitJob]API operation.
//
// [SubmitJob]: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html
type EksContainerOverride struct {

	// The arguments to the entrypoint to send to the container that overrides the
	// default arguments from the Docker image or the job definition. For more
	// information, see [Dockerfile reference: CMD]and [Define a command an arguments for a pod] in the Kubernetes documentation.
	//
	// [Define a command an arguments for a pod]: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/
	// [Dockerfile reference: CMD]: https://docs.docker.com/engine/reference/builder/#cmd
	Args []string

	// The command to send to the container that overrides the default command from
	// the Docker image or the job definition.
	Command []string

	// The environment variables to send to the container. You can add new environment
	// variables, which are added to the container at launch. Or, you can override the
	// existing environment variables from the Docker image or the job definition.
	//
	// Environment variables cannot start with " AWS_BATCH ". This naming convention is
	// reserved for variables that Batch sets.
	Env []EksContainerEnvironmentVariable

	// The override of the Docker image that's used to start the container.
	Image *string

	// A pointer to the container that you want to override. The name must match a
	// unique container name that you wish to override.
	Name *string

	// The type and amount of resources to assign to a container. These override the
	// settings in the job definition. The supported resources include memory , cpu ,
	// and nvidia.com/gpu . For more information, see [Resource management for pods and containers] in the Kubernetes documentation.
	//
	// [Resource management for pods and containers]: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	Resources *EksContainerResourceRequirements

	noSmithyDocumentSerde
}

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

func (v *EksContainerOverride) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Args != nil {
		serializeStringList(s, schemas.EksContainerOverride_args, v.Args)
	}
	if v.Command != nil {
		serializeStringList(s, schemas.EksContainerOverride_command, v.Command)
	}
	if v.Env != nil {
		serializeEksContainerEnvironmentVariables(s, schemas.EksContainerOverride_env, v.Env)
	}
	if v.Image != nil {
		s.WriteString(schemas.EksContainerOverride_image, *v.Image)
	}
	if v.Name != nil {
		s.WriteString(schemas.EksContainerOverride_name, *v.Name)
	}
	if v.Resources != nil {
		s.WriteStruct(schemas.EksContainerOverride_resources)
		v.Resources.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *EksContainerOverride) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksContainerOverride, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksContainerOverride_args:
			return deserializeStringList(d, schemas.EksContainerOverride_args, &v.Args)
		case schemas.EksContainerOverride_command:
			return deserializeStringList(d, schemas.EksContainerOverride_command, &v.Command)
		case schemas.EksContainerOverride_env:
			return deserializeEksContainerEnvironmentVariables(d, schemas.EksContainerOverride_env, &v.Env)
		case schemas.EksContainerOverride_image:
			v.Image = new(string)
			return d.ReadString(schemas.EksContainerOverride_image, v.Image)
		case schemas.EksContainerOverride_name:
			v.Name = new(string)
			return d.ReadString(schemas.EksContainerOverride_name, v.Name)
		case schemas.EksContainerOverride_resources:
			v.Resources = &EksContainerResourceRequirements{}
			return v.Resources.Deserialize(d)
		}
		return nil
	})
}

// The type and amount of resources to assign to a container. The supported
// resources include memory , cpu , and nvidia.com/gpu . For more information, see [Resource management for pods and containers]
// in the Kubernetes documentation.
//
// [Resource management for pods and containers]: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
type EksContainerResourceRequirements struct {

	// The type and quantity of the resources to reserve for the container. The values
	// vary based on the name that's specified. Resources can be requested using
	// either the limits or the requests objects.
	//
	// memory The memory hard limit (in MiB) for the container, using whole integers,
	// with a "Mi" suffix. If your container attempts to exceed the memory specified,
	// the container is terminated. You must specify at least 4 MiB of memory for a
	// job. memory can be specified in limits , requests , or both. If memory is
	// specified in both places, then the value that's specified in limits must be
	// equal to the value that's specified in requests .
	//
	// To maximize your resource utilization, provide your jobs with as much memory as
	// possible for the specific instance type that you are using. To learn how, see [Memory management]
	// in the Batch User Guide.
	//
	// cpu The number of CPUs that's reserved for the container. Values must be an
	// even multiple of 0.25 . cpu can be specified in limits , requests , or both. If
	// cpu is specified in both places, then the value that's specified in limits must
	// be at least as large as the value that's specified in requests .
	//
	// nvidia.com/gpu The number of GPUs that's reserved for the container. Values
	// must be a whole integer. memory can be specified in limits , requests , or both.
	// If memory is specified in both places, then the value that's specified in limits
	// must be equal to the value that's specified in requests .
	//
	// [Memory management]: https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html
	Limits map[string]string

	// The type and quantity of the resources to request for the container. The values
	// vary based on the name that's specified. Resources can be requested by using
	// either the limits or the requests objects.
	//
	// memory The memory hard limit (in MiB) for the container, using whole integers,
	// with a "Mi" suffix. If your container attempts to exceed the memory specified,
	// the container is terminated. You must specify at least 4 MiB of memory for a
	// job. memory can be specified in limits , requests , or both. If memory is
	// specified in both, then the value that's specified in limits must be equal to
	// the value that's specified in requests .
	//
	// If you're trying to maximize your resource utilization by providing your jobs
	// as much memory as possible for a particular instance type, see [Memory management]in the Batch
	// User Guide.
	//
	// cpu The number of CPUs that are reserved for the container. Values must be an
	// even multiple of 0.25 . cpu can be specified in limits , requests , or both. If
	// cpu is specified in both, then the value that's specified in limits must be at
	// least as large as the value that's specified in requests .
	//
	// nvidia.com/gpu The number of GPUs that are reserved for the container. Values
	// must be a whole integer. nvidia.com/gpu can be specified in limits , requests ,
	// or both. If nvidia.com/gpu is specified in both, then the value that's
	// specified in limits must be equal to the value that's specified in requests .
	//
	// [Memory management]: https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html
	Requests map[string]string

	noSmithyDocumentSerde
}

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

func (v *EksContainerResourceRequirements) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Limits != nil {
		serializeEksLimits(s, schemas.EksContainerResourceRequirements_limits, v.Limits)
	}
	if v.Requests != nil {
		serializeEksRequests(s, schemas.EksContainerResourceRequirements_requests, v.Requests)
	}
}
func (v *EksContainerResourceRequirements) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksContainerResourceRequirements, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksContainerResourceRequirements_limits:
			return deserializeEksLimits(d, schemas.EksContainerResourceRequirements_limits, &v.Limits)
		case schemas.EksContainerResourceRequirements_requests:
			return deserializeEksRequests(d, schemas.EksContainerResourceRequirements_requests, &v.Requests)
		}
		return nil
	})
}

// The security context for a job. For more information, see [Configure a security context for a pod or container] in the Kubernetes
// documentation.
//
// [Configure a security context for a pod or container]: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
type EksContainerSecurityContext struct {

	// Whether or not a container or a Kubernetes pod is allowed to gain more
	// privileges than its parent process. The default value is false .
	AllowPrivilegeEscalation *bool

	// When this parameter is true , the container is given elevated permissions on the
	// host container instance. The level of permissions are similar to the root user
	// permissions. The default value is false . This parameter maps to privileged
	// policy in the [Privileged pod security policies]in the Kubernetes documentation.
	//
	// [Privileged pod security policies]: https://kubernetes.io/docs/concepts/security/pod-security-policy/#privileged
	Privileged *bool

	// When this parameter is true , the container is given read-only access to its
	// root file system. The default value is false . This parameter maps to
	// ReadOnlyRootFilesystem policy in the [Volumes and file systems pod security policies] in the Kubernetes documentation.
	//
	// [Volumes and file systems pod security policies]: https://kubernetes.io/docs/concepts/security/pod-security-policy/#volumes-and-file-systems
	ReadOnlyRootFilesystem *bool

	// When this parameter is specified, the container is run as the specified group
	// ID ( gid ). If this parameter isn't specified, the default is the group that's
	// specified in the image metadata. This parameter maps to RunAsGroup and MustRunAs
	// policy in the [Users and groups pod security policies]in the Kubernetes documentation.
	//
	// [Users and groups pod security policies]: https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
	RunAsGroup *int64

	// When this parameter is specified, the container is run as a user with a uid
	// other than 0. If this parameter isn't specified, so such rule is enforced. This
	// parameter maps to RunAsUser and MustRunAsNonRoot policy in the [Users and groups pod security policies] in the
	// Kubernetes documentation.
	//
	// [Users and groups pod security policies]: https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
	RunAsNonRoot *bool

	// When this parameter is specified, the container is run as the specified user ID
	// ( uid ). If this parameter isn't specified, the default is the user that's
	// specified in the image metadata. This parameter maps to RunAsUser and MustRanAs
	// policy in the [Users and groups pod security policies]in the Kubernetes documentation.
	//
	// [Users and groups pod security policies]: https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
	RunAsUser *int64

	noSmithyDocumentSerde
}

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

func (v *EksContainerSecurityContext) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AllowPrivilegeEscalation != nil {
		s.WriteBool(schemas.EksContainerSecurityContext_allowPrivilegeEscalation, *v.AllowPrivilegeEscalation)
	}
	if v.Privileged != nil {
		s.WriteBool(schemas.EksContainerSecurityContext_privileged, *v.Privileged)
	}
	if v.ReadOnlyRootFilesystem != nil {
		s.WriteBool(schemas.EksContainerSecurityContext_readOnlyRootFilesystem, *v.ReadOnlyRootFilesystem)
	}
	if v.RunAsGroup != nil {
		s.WriteInt64(schemas.EksContainerSecurityContext_runAsGroup, *v.RunAsGroup)
	}
	if v.RunAsNonRoot != nil {
		s.WriteBool(schemas.EksContainerSecurityContext_runAsNonRoot, *v.RunAsNonRoot)
	}
	if v.RunAsUser != nil {
		s.WriteInt64(schemas.EksContainerSecurityContext_runAsUser, *v.RunAsUser)
	}
}
func (v *EksContainerSecurityContext) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksContainerSecurityContext, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksContainerSecurityContext_allowPrivilegeEscalation:
			v.AllowPrivilegeEscalation = new(bool)
			return d.ReadBool(schemas.EksContainerSecurityContext_allowPrivilegeEscalation, v.AllowPrivilegeEscalation)
		case schemas.EksContainerSecurityContext_privileged:
			v.Privileged = new(bool)
			return d.ReadBool(schemas.EksContainerSecurityContext_privileged, v.Privileged)
		case schemas.EksContainerSecurityContext_readOnlyRootFilesystem:
			v.ReadOnlyRootFilesystem = new(bool)
			return d.ReadBool(schemas.EksContainerSecurityContext_readOnlyRootFilesystem, v.ReadOnlyRootFilesystem)
		case schemas.EksContainerSecurityContext_runAsGroup:
			v.RunAsGroup = new(int64)
			return d.ReadInt64(schemas.EksContainerSecurityContext_runAsGroup, v.RunAsGroup)
		case schemas.EksContainerSecurityContext_runAsNonRoot:
			v.RunAsNonRoot = new(bool)
			return d.ReadBool(schemas.EksContainerSecurityContext_runAsNonRoot, v.RunAsNonRoot)
		case schemas.EksContainerSecurityContext_runAsUser:
			v.RunAsUser = new(int64)
			return d.ReadInt64(schemas.EksContainerSecurityContext_runAsUser, v.RunAsUser)
		}
		return nil
	})
}

// The volume mounts for a container for an Amazon EKS job. For more information
// about volumes and volume mounts in Kubernetes, see [Volumes]in the Kubernetes
// documentation.
//
// [Volumes]: https://kubernetes.io/docs/concepts/storage/volumes/
type EksContainerVolumeMount struct {

	// The path on the container where the volume is mounted.
	MountPath *string

	// The name the volume mount. This must match the name of one of the volumes in
	// the pod.
	Name *string

	// If this value is true , the container has read-only access to the volume.
	// Otherwise, the container can write to the volume. The default value is false .
	ReadOnly *bool

	// A sub-path inside the referenced volume instead of its root.
	SubPath *string

	noSmithyDocumentSerde
}

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

func (v *EksContainerVolumeMount) SerializeMembers(s smithy.ShapeSerializer) {
	if v.MountPath != nil {
		s.WriteString(schemas.EksContainerVolumeMount_mountPath, *v.MountPath)
	}
	if v.Name != nil {
		s.WriteString(schemas.EksContainerVolumeMount_name, *v.Name)
	}
	if v.ReadOnly != nil {
		s.WriteBool(schemas.EksContainerVolumeMount_readOnly, *v.ReadOnly)
	}
	if v.SubPath != nil {
		s.WriteString(schemas.EksContainerVolumeMount_subPath, *v.SubPath)
	}
}
func (v *EksContainerVolumeMount) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksContainerVolumeMount, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksContainerVolumeMount_mountPath:
			v.MountPath = new(string)
			return d.ReadString(schemas.EksContainerVolumeMount_mountPath, v.MountPath)
		case schemas.EksContainerVolumeMount_name:
			v.Name = new(string)
			return d.ReadString(schemas.EksContainerVolumeMount_name, v.Name)
		case schemas.EksContainerVolumeMount_readOnly:
			v.ReadOnly = new(bool)
			return d.ReadBool(schemas.EksContainerVolumeMount_readOnly, v.ReadOnly)
		case schemas.EksContainerVolumeMount_subPath:
			v.SubPath = new(string)
			return d.ReadString(schemas.EksContainerVolumeMount_subPath, v.SubPath)
		}
		return nil
	})
}

// Specifies the configuration of a Kubernetes emptyDir volume. An emptyDir volume
// is first created when a pod is assigned to a node. It exists as long as that pod
// is running on that node. The emptyDir volume is initially empty. All containers
// in the pod can read and write the files in the emptyDir volume. However, the
// emptyDir volume can be mounted at the same or different paths in each container.
// When a pod is removed from a node for any reason, the data in the emptyDir is
// deleted permanently. For more information, see [emptyDir]in the Kubernetes documentation.
//
// [emptyDir]: https://kubernetes.io/docs/concepts/storage/volumes/#emptydir
type EksEmptyDir struct {

	// The medium to store the volume. The default value is an empty string, which
	// uses the storage of the node.
	//
	// ""  (Default) Use the disk storage of the node.
	//
	// "Memory" Use the tmpfs volume that's backed by the RAM of the node. Contents of
	// the volume are lost when the node reboots, and any storage on the volume counts
	// against the container's memory limit.
	Medium *string

	// The maximum size of the volume. By default, there's no maximum size defined.
	SizeLimit *string

	noSmithyDocumentSerde
}

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

func (v *EksEmptyDir) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Medium != nil {
		s.WriteString(schemas.EksEmptyDir_medium, *v.Medium)
	}
	if v.SizeLimit != nil {
		s.WriteString(schemas.EksEmptyDir_sizeLimit, *v.SizeLimit)
	}
}
func (v *EksEmptyDir) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksEmptyDir, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksEmptyDir_medium:
			v.Medium = new(string)
			return d.ReadString(schemas.EksEmptyDir_medium, v.Medium)
		case schemas.EksEmptyDir_sizeLimit:
			v.SizeLimit = new(string)
			return d.ReadString(schemas.EksEmptyDir_sizeLimit, v.SizeLimit)
		}
		return nil
	})
}

// Specifies the configuration of a Kubernetes hostPath volume. A hostPath volume
// mounts an existing file or directory from the host node's filesystem into your
// pod. For more information, see [hostPath]in the Kubernetes documentation.
//
// [hostPath]: https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
type EksHostPath struct {

	// The path of the file or directory on the host to mount into containers on the
	// pod.
	Path *string

	noSmithyDocumentSerde
}

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

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

// Describes and uniquely identifies Kubernetes resources. For example, the
// compute environment that a pod runs in or the jobID for a job running in the
// pod. For more information, see [Understanding Kubernetes Objects]in the Kubernetes documentation.
//
// [Understanding Kubernetes Objects]: https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/
type EksMetadata struct {

	// Key-value pairs used to attach arbitrary, non-identifying metadata to
	// Kubernetes objects. Valid annotation keys have two segments: an optional prefix
	// and a name, separated by a slash (/).
	//
	//   - The prefix is optional and must be 253 characters or less. If specified,
	//   the prefix must be a DNS subdomain− a series of DNS labels separated by dots
	//   (.), and it must end with a slash (/).
	//
	//   - The name segment is required and must be 63 characters or less. It can
	//   include alphanumeric characters ([a-z0-9A-Z]), dashes (-), underscores (_), and
	//   dots (.), but must begin and end with an alphanumeric character.
	//
	// Annotation values must be 255 characters or less.
	//
	// Annotations can be added or modified at any time. Each resource can have
	// multiple annotations.
	Annotations map[string]string

	// Key-value pairs used to identify, sort, and organize cube resources. Can
	// contain up to 63 uppercase letters, lowercase letters, numbers, hyphens (-), and
	// underscores (_). Labels can be added or modified at any time. Each resource can
	// have multiple labels, but each key must be unique for a given object.
	Labels map[string]string

	// The namespace of the Amazon EKS cluster. In Kubernetes, namespaces provide a
	// mechanism for isolating groups of resources within a single cluster. Names of
	// resources need to be unique within a namespace, but not across namespaces. Batch
	// places Batch Job pods in this namespace. If this field is provided, the value
	// can't be empty or null. It must meet the following requirements:
	//
	//   - 1-63 characters long
	//
	//   - Can't be set to default
	//
	//   - Can't start with kube
	//
	//   - Must match the following regular expression:
	//   ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
	//
	// For more information, see [Namespaces] in the Kubernetes documentation. This namespace can
	// be different from the kubernetesNamespace set in the compute environment's
	// EksConfiguration , but must have identical role-based access control (RBAC)
	// roles as the compute environment's kubernetesNamespace . For multi-node parallel
	// jobs, the same value must be provided across all the node ranges.
	//
	// [Namespaces]: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
	Namespace *string

	noSmithyDocumentSerde
}

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

func (v *EksMetadata) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Annotations != nil {
		serializeEksAnnotationsMap(s, schemas.EksMetadata_annotations, v.Annotations)
	}
	if v.Labels != nil {
		serializeEksLabelsMap(s, schemas.EksMetadata_labels, v.Labels)
	}
	if v.Namespace != nil {
		s.WriteString(schemas.EksMetadata_namespace, *v.Namespace)
	}
}
func (v *EksMetadata) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksMetadata, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksMetadata_annotations:
			return deserializeEksAnnotationsMap(d, schemas.EksMetadata_annotations, &v.Annotations)
		case schemas.EksMetadata_labels:
			return deserializeEksLabelsMap(d, schemas.EksMetadata_labels, &v.Labels)
		case schemas.EksMetadata_namespace:
			v.Namespace = new(string)
			return d.ReadString(schemas.EksMetadata_namespace, v.Namespace)
		}
		return nil
	})
}

// A persistentVolumeClaim volume is used to mount a [PersistentVolume] into a Pod.
// PersistentVolumeClaims are a way for users to "claim" durable storage without
// knowing the details of the particular cloud environment. See the information
// about [PersistentVolumes]in the Kubernetes documentation.
//
// [PersistentVolumes]: https://kubernetes.io/docs/concepts/storage/persistent-volumes/
// [PersistentVolume]: https://kubernetes.io/docs/concepts/storage/persistent-volumes/
type EksPersistentVolumeClaim struct {

	// The name of the persistentVolumeClaim bounded to a persistentVolume . For more
	// information, see [Persistent Volume Claims]in the Kubernetes documentation.
	//
	// [Persistent Volume Claims]: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims
	//
	// This member is required.
	ClaimName *string

	// An optional boolean value indicating if the mount is read only. Default is
	// false. For more information, see [Read Only Mounts]in the Kubernetes documentation.
	//
	// [Read Only Mounts]: https://kubernetes.io/docs/concepts/storage/volumes/#read-only-mounts
	ReadOnly *bool

	noSmithyDocumentSerde
}

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

func (v *EksPersistentVolumeClaim) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ClaimName != nil {
		s.WriteString(schemas.EksPersistentVolumeClaim_claimName, *v.ClaimName)
	}
	if v.ReadOnly != nil {
		s.WriteBool(schemas.EksPersistentVolumeClaim_readOnly, *v.ReadOnly)
	}
}
func (v *EksPersistentVolumeClaim) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksPersistentVolumeClaim, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksPersistentVolumeClaim_claimName:
			v.ClaimName = new(string)
			return d.ReadString(schemas.EksPersistentVolumeClaim_claimName, v.ClaimName)
		case schemas.EksPersistentVolumeClaim_readOnly:
			v.ReadOnly = new(bool)
			return d.ReadBool(schemas.EksPersistentVolumeClaim_readOnly, v.ReadOnly)
		}
		return nil
	})
}

// The properties for the pod.
type EksPodProperties struct {

	// The properties of the container that's used on the Amazon EKS pod.
	//
	// This object is limited to 10 elements.
	Containers []EksContainer

	// The DNS policy for the pod. The default value is ClusterFirst . If the
	// hostNetwork parameter is not specified, the default is ClusterFirstWithHostNet .
	// ClusterFirst indicates that any DNS query that does not match the configured
	// cluster domain suffix is forwarded to the upstream nameserver inherited from the
	// node. For more information, see [Pod's DNS policy]in the Kubernetes documentation.
	//
	// Valid values: Default | ClusterFirst | ClusterFirstWithHostNet
	//
	// [Pod's DNS policy]: https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy
	DnsPolicy *string

	// Indicates if the pod uses the hosts' network IP address. The default value is
	// true . Setting this to false enables the Kubernetes pod networking model. Most
	// Batch workloads are egress-only and don't require the overhead of IP allocation
	// for each pod for incoming connections. For more information, see [Host namespaces]and [Pod networking] in the
	// Kubernetes documentation.
	//
	// [Pod networking]: https://kubernetes.io/docs/concepts/workloads/pods/#pod-networking
	// [Host namespaces]: https://kubernetes.io/docs/concepts/security/pod-security-policy/#host-namespaces
	HostNetwork *bool

	// References a Kubernetes secret resource. It holds a list of secrets. These
	// secrets help to gain access to pull an images from a private registry.
	//
	// ImagePullSecret$name is required when this object is used.
	ImagePullSecrets []ImagePullSecret

	// These containers run before application containers, always runs to completion,
	// and must complete successfully before the next container starts. These
	// containers are registered with the Amazon EKS Connector agent and persists the
	// registration information in the Kubernetes backend data store. For more
	// information, see [Init Containers]in the Kubernetes documentation.
	//
	// This object is limited to 10 elements.
	//
	// [Init Containers]: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
	InitContainers []EksContainer

	// Metadata about the Kubernetes pod. For more information, see [Understanding Kubernetes Objects] in the Kubernetes
	// documentation.
	//
	// [Understanding Kubernetes Objects]: https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/
	Metadata *EksMetadata

	// The name of the service account that's used to run the pod. For more
	// information, see [Kubernetes service accounts]and [Configure a Kubernetes service account to assume an IAM role] in the Amazon EKS User Guide and [Configure service accounts for pods] in the Kubernetes
	// documentation.
	//
	// [Kubernetes service accounts]: https://docs.aws.amazon.com/eks/latest/userguide/service-accounts.html
	// [Configure service accounts for pods]: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
	// [Configure a Kubernetes service account to assume an IAM role]: https://docs.aws.amazon.com/eks/latest/userguide/associate-service-account-role.html
	ServiceAccountName *string

	// Indicates if the processes in a container are shared, or visible, to other
	// containers in the same pod. For more information, see [Share Process Namespace between Containers in a Pod].
	//
	// [Share Process Namespace between Containers in a Pod]: https://kubernetes.io/docs/tasks/configure-pod-container/share-process-namespace/
	ShareProcessNamespace *bool

	// Specifies the volumes for a job definition that uses Amazon EKS resources.
	Volumes []EksVolume

	noSmithyDocumentSerde
}

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

func (v *EksPodProperties) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Containers != nil {
		serializeEksContainers(s, schemas.EksPodProperties_containers, v.Containers)
	}
	if v.DnsPolicy != nil {
		s.WriteString(schemas.EksPodProperties_dnsPolicy, *v.DnsPolicy)
	}
	if v.HostNetwork != nil {
		s.WriteBool(schemas.EksPodProperties_hostNetwork, *v.HostNetwork)
	}
	if v.ImagePullSecrets != nil {
		serializeImagePullSecrets(s, schemas.EksPodProperties_imagePullSecrets, v.ImagePullSecrets)
	}
	if v.InitContainers != nil {
		serializeEksContainers(s, schemas.EksPodProperties_initContainers, v.InitContainers)
	}
	if v.Metadata != nil {
		s.WriteStruct(schemas.EksPodProperties_metadata)
		v.Metadata.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ServiceAccountName != nil {
		s.WriteString(schemas.EksPodProperties_serviceAccountName, *v.ServiceAccountName)
	}
	if v.ShareProcessNamespace != nil {
		s.WriteBool(schemas.EksPodProperties_shareProcessNamespace, *v.ShareProcessNamespace)
	}
	if v.Volumes != nil {
		serializeEksVolumes(s, schemas.EksPodProperties_volumes, v.Volumes)
	}
}
func (v *EksPodProperties) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksPodProperties, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksPodProperties_containers:
			return deserializeEksContainers(d, schemas.EksPodProperties_containers, &v.Containers)
		case schemas.EksPodProperties_dnsPolicy:
			v.DnsPolicy = new(string)
			return d.ReadString(schemas.EksPodProperties_dnsPolicy, v.DnsPolicy)
		case schemas.EksPodProperties_hostNetwork:
			v.HostNetwork = new(bool)
			return d.ReadBool(schemas.EksPodProperties_hostNetwork, v.HostNetwork)
		case schemas.EksPodProperties_imagePullSecrets:
			return deserializeImagePullSecrets(d, schemas.EksPodProperties_imagePullSecrets, &v.ImagePullSecrets)
		case schemas.EksPodProperties_initContainers:
			return deserializeEksContainers(d, schemas.EksPodProperties_initContainers, &v.InitContainers)
		case schemas.EksPodProperties_metadata:
			v.Metadata = &EksMetadata{}
			return v.Metadata.Deserialize(d)
		case schemas.EksPodProperties_serviceAccountName:
			v.ServiceAccountName = new(string)
			return d.ReadString(schemas.EksPodProperties_serviceAccountName, v.ServiceAccountName)
		case schemas.EksPodProperties_shareProcessNamespace:
			v.ShareProcessNamespace = new(bool)
			return d.ReadBool(schemas.EksPodProperties_shareProcessNamespace, v.ShareProcessNamespace)
		case schemas.EksPodProperties_volumes:
			return deserializeEksVolumes(d, schemas.EksPodProperties_volumes, &v.Volumes)
		}
		return nil
	})
}

// The details for the pod.
type EksPodPropertiesDetail struct {

	// The properties of the container that's used on the Amazon EKS pod.
	Containers []EksContainerDetail

	// The DNS policy for the pod. The default value is ClusterFirst . If the
	// hostNetwork parameter is not specified, the default is ClusterFirstWithHostNet .
	// ClusterFirst indicates that any DNS query that does not match the configured
	// cluster domain suffix is forwarded to the upstream nameserver inherited from the
	// node. If no value was specified for dnsPolicy in the [RegisterJobDefinition] API operation, then no
	// value will be returned for dnsPolicy by either of [DescribeJobDefinitions] or [DescribeJobs] API operations. The pod
	// spec setting will contain either ClusterFirst or ClusterFirstWithHostNet ,
	// depending on the value of the hostNetwork parameter. For more information, see [Pod's DNS policy]
	// in the Kubernetes documentation.
	//
	// Valid values: Default | ClusterFirst | ClusterFirstWithHostNet
	//
	// [DescribeJobs]: https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html
	// [RegisterJobDefinition]: https://docs.aws.amazon.com/batch/latest/APIReference/API_RegisterJobDefinition.html
	// [DescribeJobDefinitions]: https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobDefinitions.html
	// [Pod's DNS policy]: https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy
	DnsPolicy *string

	// Indicates if the pod uses the hosts' network IP address. The default value is
	// true . Setting this to false enables the Kubernetes pod networking model. Most
	// Batch workloads are egress-only and don't require the overhead of IP allocation
	// for each pod for incoming connections. For more information, see [Host namespaces]and [Pod networking] in the
	// Kubernetes documentation.
	//
	// [Pod networking]: https://kubernetes.io/docs/concepts/workloads/pods/#pod-networking
	// [Host namespaces]: https://kubernetes.io/docs/concepts/security/pod-security-policy/#host-namespaces
	HostNetwork *bool

	// Displays the reference pointer to the Kubernetes secret resource. These secrets
	// help to gain access to pull an images from a private registry.
	ImagePullSecrets []ImagePullSecret

	// The container registered with the Amazon EKS Connector agent and persists the
	// registration information in the Kubernetes backend data store.
	InitContainers []EksContainerDetail

	// Describes and uniquely identifies Kubernetes resources. For example, the
	// compute environment that a pod runs in or the jobID for a job running in the
	// pod. For more information, see [Understanding Kubernetes Objects]in the Kubernetes documentation.
	//
	// [Understanding Kubernetes Objects]: https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/
	Metadata *EksMetadata

	// The name of the node for this job.
	NodeName *string

	// The name of the pod for this job.
	PodName *string

	// The name of the service account that's used to run the pod. For more
	// information, see [Kubernetes service accounts]and [Configure a Kubernetes service account to assume an IAM role] in the Amazon EKS User Guide and [Configure service accounts for pods] in the Kubernetes
	// documentation.
	//
	// [Kubernetes service accounts]: https://docs.aws.amazon.com/eks/latest/userguide/service-accounts.html
	// [Configure service accounts for pods]: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
	// [Configure a Kubernetes service account to assume an IAM role]: https://docs.aws.amazon.com/eks/latest/userguide/associate-service-account-role.html
	ServiceAccountName *string

	// Indicates if the processes in a container are shared, or visible, to other
	// containers in the same pod. For more information, see [Share Process Namespace between Containers in a Pod].
	//
	// [Share Process Namespace between Containers in a Pod]: https://kubernetes.io/docs/tasks/configure-pod-container/share-process-namespace/
	ShareProcessNamespace *bool

	// Specifies the volumes for a job definition using Amazon EKS resources.
	Volumes []EksVolume

	noSmithyDocumentSerde
}

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

func (v *EksPodPropertiesDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Containers != nil {
		serializeEksContainerDetails(s, schemas.EksPodPropertiesDetail_containers, v.Containers)
	}
	if v.DnsPolicy != nil {
		s.WriteString(schemas.EksPodPropertiesDetail_dnsPolicy, *v.DnsPolicy)
	}
	if v.HostNetwork != nil {
		s.WriteBool(schemas.EksPodPropertiesDetail_hostNetwork, *v.HostNetwork)
	}
	if v.ImagePullSecrets != nil {
		serializeImagePullSecrets(s, schemas.EksPodPropertiesDetail_imagePullSecrets, v.ImagePullSecrets)
	}
	if v.InitContainers != nil {
		serializeEksContainerDetails(s, schemas.EksPodPropertiesDetail_initContainers, v.InitContainers)
	}
	if v.Metadata != nil {
		s.WriteStruct(schemas.EksPodPropertiesDetail_metadata)
		v.Metadata.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.NodeName != nil {
		s.WriteString(schemas.EksPodPropertiesDetail_nodeName, *v.NodeName)
	}
	if v.PodName != nil {
		s.WriteString(schemas.EksPodPropertiesDetail_podName, *v.PodName)
	}
	if v.ServiceAccountName != nil {
		s.WriteString(schemas.EksPodPropertiesDetail_serviceAccountName, *v.ServiceAccountName)
	}
	if v.ShareProcessNamespace != nil {
		s.WriteBool(schemas.EksPodPropertiesDetail_shareProcessNamespace, *v.ShareProcessNamespace)
	}
	if v.Volumes != nil {
		serializeEksVolumes(s, schemas.EksPodPropertiesDetail_volumes, v.Volumes)
	}
}
func (v *EksPodPropertiesDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksPodPropertiesDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksPodPropertiesDetail_containers:
			return deserializeEksContainerDetails(d, schemas.EksPodPropertiesDetail_containers, &v.Containers)
		case schemas.EksPodPropertiesDetail_dnsPolicy:
			v.DnsPolicy = new(string)
			return d.ReadString(schemas.EksPodPropertiesDetail_dnsPolicy, v.DnsPolicy)
		case schemas.EksPodPropertiesDetail_hostNetwork:
			v.HostNetwork = new(bool)
			return d.ReadBool(schemas.EksPodPropertiesDetail_hostNetwork, v.HostNetwork)
		case schemas.EksPodPropertiesDetail_imagePullSecrets:
			return deserializeImagePullSecrets(d, schemas.EksPodPropertiesDetail_imagePullSecrets, &v.ImagePullSecrets)
		case schemas.EksPodPropertiesDetail_initContainers:
			return deserializeEksContainerDetails(d, schemas.EksPodPropertiesDetail_initContainers, &v.InitContainers)
		case schemas.EksPodPropertiesDetail_metadata:
			v.Metadata = &EksMetadata{}
			return v.Metadata.Deserialize(d)
		case schemas.EksPodPropertiesDetail_nodeName:
			v.NodeName = new(string)
			return d.ReadString(schemas.EksPodPropertiesDetail_nodeName, v.NodeName)
		case schemas.EksPodPropertiesDetail_podName:
			v.PodName = new(string)
			return d.ReadString(schemas.EksPodPropertiesDetail_podName, v.PodName)
		case schemas.EksPodPropertiesDetail_serviceAccountName:
			v.ServiceAccountName = new(string)
			return d.ReadString(schemas.EksPodPropertiesDetail_serviceAccountName, v.ServiceAccountName)
		case schemas.EksPodPropertiesDetail_shareProcessNamespace:
			v.ShareProcessNamespace = new(bool)
			return d.ReadBool(schemas.EksPodPropertiesDetail_shareProcessNamespace, v.ShareProcessNamespace)
		case schemas.EksPodPropertiesDetail_volumes:
			return deserializeEksVolumes(d, schemas.EksPodPropertiesDetail_volumes, &v.Volumes)
		}
		return nil
	})
}

// An object that contains overrides for the Kubernetes pod properties of a job.
type EksPodPropertiesOverride struct {

	// The overrides for the container that's used on the Amazon EKS pod.
	Containers []EksContainerOverride

	// The overrides for the initContainers defined in the Amazon EKS pod. These
	// containers run before application containers, always run to completion, and must
	// complete successfully before the next container starts. These containers are
	// registered with the Amazon EKS Connector agent and persists the registration
	// information in the Kubernetes backend data store. For more information, see [Init Containers]in
	// the Kubernetes documentation.
	//
	// [Init Containers]: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
	InitContainers []EksContainerOverride

	// Metadata about the overrides for the container that's used on the Amazon EKS
	// pod.
	Metadata *EksMetadata

	noSmithyDocumentSerde
}

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

func (v *EksPodPropertiesOverride) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Containers != nil {
		serializeEksContainerOverrideList(s, schemas.EksPodPropertiesOverride_containers, v.Containers)
	}
	if v.InitContainers != nil {
		serializeEksContainerOverrideList(s, schemas.EksPodPropertiesOverride_initContainers, v.InitContainers)
	}
	if v.Metadata != nil {
		s.WriteStruct(schemas.EksPodPropertiesOverride_metadata)
		v.Metadata.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *EksPodPropertiesOverride) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksPodPropertiesOverride, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksPodPropertiesOverride_containers:
			return deserializeEksContainerOverrideList(d, schemas.EksPodPropertiesOverride_containers, &v.Containers)
		case schemas.EksPodPropertiesOverride_initContainers:
			return deserializeEksContainerOverrideList(d, schemas.EksPodPropertiesOverride_initContainers, &v.InitContainers)
		case schemas.EksPodPropertiesOverride_metadata:
			v.Metadata = &EksMetadata{}
			return v.Metadata.Deserialize(d)
		}
		return nil
	})
}

// An object that contains the properties for the Kubernetes resources of a job.
type EksProperties struct {

	// The properties for the Kubernetes pod resources of a job.
	PodProperties *EksPodProperties

	noSmithyDocumentSerde
}

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

func (v *EksProperties) SerializeMembers(s smithy.ShapeSerializer) {
	if v.PodProperties != nil {
		s.WriteStruct(schemas.EksProperties_podProperties)
		v.PodProperties.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *EksProperties) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksProperties, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksProperties_podProperties:
			v.PodProperties = &EksPodProperties{}
			return v.PodProperties.Deserialize(d)
		}
		return nil
	})
}

// An object that contains the details for the Kubernetes resources of a job.
type EksPropertiesDetail struct {

	// The properties for the Kubernetes pod resources of a job.
	PodProperties *EksPodPropertiesDetail

	noSmithyDocumentSerde
}

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

func (v *EksPropertiesDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.PodProperties != nil {
		s.WriteStruct(schemas.EksPropertiesDetail_podProperties)
		v.PodProperties.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *EksPropertiesDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksPropertiesDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksPropertiesDetail_podProperties:
			v.PodProperties = &EksPodPropertiesDetail{}
			return v.PodProperties.Deserialize(d)
		}
		return nil
	})
}

// An object that contains overrides for the Kubernetes resources of a job.
type EksPropertiesOverride struct {

	// The overrides for the Kubernetes pod resources of a job.
	PodProperties *EksPodPropertiesOverride

	noSmithyDocumentSerde
}

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

func (v *EksPropertiesOverride) SerializeMembers(s smithy.ShapeSerializer) {
	if v.PodProperties != nil {
		s.WriteStruct(schemas.EksPropertiesOverride_podProperties)
		v.PodProperties.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *EksPropertiesOverride) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksPropertiesOverride, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksPropertiesOverride_podProperties:
			v.PodProperties = &EksPodPropertiesOverride{}
			return v.PodProperties.Deserialize(d)
		}
		return nil
	})
}

// Specifies the configuration of a Kubernetes secret volume. For more
// information, see [secret]in the Kubernetes documentation.
//
// [secret]: https://kubernetes.io/docs/concepts/storage/volumes/#secret
type EksSecret struct {

	// The name of the secret. The name must be allowed as a DNS subdomain name. For
	// more information, see [DNS subdomain names]in the Kubernetes documentation.
	//
	// [DNS subdomain names]: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
	//
	// This member is required.
	SecretName *string

	// Specifies whether the secret or the secret's keys must be defined.
	Optional *bool

	noSmithyDocumentSerde
}

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

func (v *EksSecret) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Optional != nil {
		s.WriteBool(schemas.EksSecret_optional, *v.Optional)
	}
	if v.SecretName != nil {
		s.WriteString(schemas.EksSecret_secretName, *v.SecretName)
	}
}
func (v *EksSecret) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksSecret, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksSecret_optional:
			v.Optional = new(bool)
			return d.ReadBool(schemas.EksSecret_optional, v.Optional)
		case schemas.EksSecret_secretName:
			v.SecretName = new(string)
			return d.ReadString(schemas.EksSecret_secretName, v.SecretName)
		}
		return nil
	})
}

// Specifies an Amazon EKS volume for a job definition.
type EksVolume struct {

	// The name of the volume. The name must be allowed as a DNS subdomain name. For
	// more information, see [DNS subdomain names]in the Kubernetes documentation.
	//
	// [DNS subdomain names]: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
	//
	// This member is required.
	Name *string

	// Specifies the configuration of a Kubernetes emptyDir volume. For more
	// information, see [emptyDir]in the Kubernetes documentation.
	//
	// [emptyDir]: https://kubernetes.io/docs/concepts/storage/volumes/#emptydir
	EmptyDir *EksEmptyDir

	// Specifies the configuration of a Kubernetes hostPath volume. For more
	// information, see [hostPath]in the Kubernetes documentation.
	//
	// [hostPath]: https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
	HostPath *EksHostPath

	// Specifies the configuration of a Kubernetes persistentVolumeClaim bounded to a
	// persistentVolume . For more information, see [Persistent Volume Claims] in the Kubernetes documentation.
	//
	// [Persistent Volume Claims]: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims
	PersistentVolumeClaim *EksPersistentVolumeClaim

	// Specifies the configuration of a Kubernetes secret volume. For more
	// information, see [secret]in the Kubernetes documentation.
	//
	// [secret]: https://kubernetes.io/docs/concepts/storage/volumes/#secret
	Secret *EksSecret

	noSmithyDocumentSerde
}

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

func (v *EksVolume) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EmptyDir != nil {
		s.WriteStruct(schemas.EksVolume_emptyDir)
		v.EmptyDir.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.HostPath != nil {
		s.WriteStruct(schemas.EksVolume_hostPath)
		v.HostPath.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Name != nil {
		s.WriteString(schemas.EksVolume_name, *v.Name)
	}
	if v.PersistentVolumeClaim != nil {
		s.WriteStruct(schemas.EksVolume_persistentVolumeClaim)
		v.PersistentVolumeClaim.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Secret != nil {
		s.WriteStruct(schemas.EksVolume_secret)
		v.Secret.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *EksVolume) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EksVolume, func(s *smithy.Schema) error {
		switch s {
		case schemas.EksVolume_emptyDir:
			v.EmptyDir = &EksEmptyDir{}
			return v.EmptyDir.Deserialize(d)
		case schemas.EksVolume_hostPath:
			v.HostPath = &EksHostPath{}
			return v.HostPath.Deserialize(d)
		case schemas.EksVolume_name:
			v.Name = new(string)
			return d.ReadString(schemas.EksVolume_name, v.Name)
		case schemas.EksVolume_persistentVolumeClaim:
			v.PersistentVolumeClaim = &EksPersistentVolumeClaim{}
			return v.PersistentVolumeClaim.Deserialize(d)
		case schemas.EksVolume_secret:
			v.Secret = &EksSecret{}
			return v.Secret.Deserialize(d)
		}
		return nil
	})
}

// The amount of ephemeral storage to allocate for the task. This parameter is
// used to expand the total amount of ephemeral storage available, beyond the
// default amount, for tasks hosted on Fargate.
type EphemeralStorage struct {

	// The total amount, in GiB, of ephemeral storage to set for the task. The minimum
	// supported value is 21 GiB and the maximum supported value is 200 GiB.
	//
	// This member is required.
	SizeInGiB *int32

	noSmithyDocumentSerde
}

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

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

// Specifies an array of up to 5 conditions to be met, and an action to take ( RETRY
// or EXIT ) if all conditions are met. If none of the EvaluateOnExit conditions
// in a RetryStrategy match, then the job is retried.
type EvaluateOnExit struct {

	// Specifies the action to take if all of the specified conditions ( onStatusReason
	// , onReason , and onExitCode ) are met. The values aren't case sensitive.
	//
	// This member is required.
	Action RetryAction

	// Contains a glob pattern to match against the decimal representation of the
	// ExitCode returned for a job. The pattern can be up to 512 characters long. It
	// can contain only numbers, and can end with an asterisk (*) so that only the
	// start of the string needs to be an exact match.
	//
	// The string can contain up to 512 characters.
	OnExitCode *string

	// Contains a glob pattern to match against the Reason returned for a job. The
	// pattern can contain up to 512 characters. It can contain letters, numbers,
	// periods (.), colons (:), and white space (including spaces and tabs). It can
	// optionally end with an asterisk (*) so that only the start of the string needs
	// to be an exact match.
	OnReason *string

	// Contains a glob pattern to match against the StatusReason returned for a job.
	// The pattern can contain up to 512 characters. It can contain letters, numbers,
	// periods (.), colons (:), and white spaces (including spaces or tabs). It can
	// optionally end with an asterisk (*) so that only the start of the string needs
	// to be an exact match.
	OnStatusReason *string

	noSmithyDocumentSerde
}

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

func (v *EvaluateOnExit) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Action != "" {
		s.WriteString(schemas.EvaluateOnExit_action, string(v.Action))
	}
	if v.OnExitCode != nil {
		s.WriteString(schemas.EvaluateOnExit_onExitCode, *v.OnExitCode)
	}
	if v.OnReason != nil {
		s.WriteString(schemas.EvaluateOnExit_onReason, *v.OnReason)
	}
	if v.OnStatusReason != nil {
		s.WriteString(schemas.EvaluateOnExit_onStatusReason, *v.OnStatusReason)
	}
}
func (v *EvaluateOnExit) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.EvaluateOnExit, func(s *smithy.Schema) error {
		switch s {
		case schemas.EvaluateOnExit_action:
			var ev string
			if err := d.ReadString(schemas.EvaluateOnExit_action, &ev); err != nil {
				return err
			}
			v.Action = RetryAction(ev)
			return nil
		case schemas.EvaluateOnExit_onExitCode:
			v.OnExitCode = new(string)
			return d.ReadString(schemas.EvaluateOnExit_onExitCode, v.OnExitCode)
		case schemas.EvaluateOnExit_onReason:
			v.OnReason = new(string)
			return d.ReadString(schemas.EvaluateOnExit_onReason, v.OnReason)
		case schemas.EvaluateOnExit_onStatusReason:
			v.OnStatusReason = new(string)
			return d.ReadString(schemas.EvaluateOnExit_onStatusReason, v.OnStatusReason)
		}
		return nil
	})
}

// The capacity usage for a fairshare scheduling job queue.
type FairshareCapacityUsage struct {

	// The unit of measure for the capacity usage. For compute jobs, this is VCPU for
	// Amazon EC2 and cpu for Amazon EKS. For service jobs, this is the instance type.
	CapacityUnit *string

	// The quantity of capacity being used, measured in the units specified by
	// capacityUnit .
	Quantity *float64

	noSmithyDocumentSerde
}

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

func (v *FairshareCapacityUsage) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUnit != nil {
		s.WriteString(schemas.FairshareCapacityUsage_capacityUnit, *v.CapacityUnit)
	}
	if v.Quantity != nil {
		s.WriteFloat64(schemas.FairshareCapacityUsage_quantity, *v.Quantity)
	}
}
func (v *FairshareCapacityUsage) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FairshareCapacityUsage, func(s *smithy.Schema) error {
		switch s {
		case schemas.FairshareCapacityUsage_capacityUnit:
			v.CapacityUnit = new(string)
			return d.ReadString(schemas.FairshareCapacityUsage_capacityUnit, v.CapacityUnit)
		case schemas.FairshareCapacityUsage_quantity:
			v.Quantity = new(float64)
			return d.ReadFloat64(schemas.FairshareCapacityUsage_quantity, v.Quantity)
		}
		return nil
	})
}

// The capacity utilization for a specific share in a fairshare scheduling job
// queue, including the share identifier and its current usage.
type FairshareCapacityUtilization struct {

	// The capacity usage information for this share, including the unit of measure
	// and quantity being used. This is VCPU for Amazon EC2 and cpu for Amazon EKS.
	CapacityUsage []FairshareCapacityUsage

	// The share identifier for the fairshare scheduling job queue.
	ShareIdentifier *string

	noSmithyDocumentSerde
}

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

func (v *FairshareCapacityUtilization) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUsage != nil {
		serializeFairshareCapacityUsageList(s, schemas.FairshareCapacityUtilization_capacityUsage, v.CapacityUsage)
	}
	if v.ShareIdentifier != nil {
		s.WriteString(schemas.FairshareCapacityUtilization_shareIdentifier, *v.ShareIdentifier)
	}
}
func (v *FairshareCapacityUtilization) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FairshareCapacityUtilization, func(s *smithy.Schema) error {
		switch s {
		case schemas.FairshareCapacityUtilization_capacityUsage:
			return deserializeFairshareCapacityUsageList(d, schemas.FairshareCapacityUtilization_capacityUsage, &v.CapacityUsage)
		case schemas.FairshareCapacityUtilization_shareIdentifier:
			v.ShareIdentifier = new(string)
			return d.ReadString(schemas.FairshareCapacityUtilization_shareIdentifier, v.ShareIdentifier)
		}
		return nil
	})
}

// The fair-share scheduling policy details.
type FairsharePolicy struct {

	// A value used to reserve some of the available maximum vCPU for share
	// identifiers that aren't already used.
	//
	// The reserved ratio is (computeReservation/100)^ActiveFairShares  where
	// ActiveFairShares is the number of active share identifiers.
	//
	// For example, a computeReservation value of 50 indicates that Batch reserves 50%
	// of the maximum available vCPU if there's only one share identifier. It reserves
	// 25% if there are two share identifiers. It reserves 12.5% if there are three
	// share identifiers. A computeReservation value of 25 indicates that Batch should
	// reserve 25% of the maximum available vCPU if there's only one share identifier,
	// 6.25% if there are two fair share identifiers, and 1.56% if there are three
	// share identifiers.
	//
	// The minimum value is 0 and the maximum value is 99.
	ComputeReservation *int32

	// The amount of time (in seconds) to use to calculate a fair-share percentage for
	// each share identifier in use. A value of zero (0) indicates the default minimum
	// time window (600 seconds). The maximum supported value is 604800 (1 week).
	//
	// The decay allows for more recently run jobs to have more weight than jobs that
	// ran earlier. Consider adjusting this number if you have jobs that (on average)
	// run longer than ten minutes, or a large difference in job count or job run times
	// between share identifiers, and the allocation of resources doesn't meet your
	// needs.
	ShareDecaySeconds *int32

	// An array of SharedIdentifier objects that contain the weights for the share
	// identifiers for the fair-share policy. Share identifiers that aren't included
	// have a default weight of 1.0 .
	ShareDistribution []ShareAttributes

	noSmithyDocumentSerde
}

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

func (v *FairsharePolicy) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ComputeReservation != nil {
		s.WriteInt32(schemas.FairsharePolicy_computeReservation, *v.ComputeReservation)
	}
	if v.ShareDecaySeconds != nil {
		s.WriteInt32(schemas.FairsharePolicy_shareDecaySeconds, *v.ShareDecaySeconds)
	}
	if v.ShareDistribution != nil {
		serializeShareAttributesList(s, schemas.FairsharePolicy_shareDistribution, v.ShareDistribution)
	}
}
func (v *FairsharePolicy) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FairsharePolicy, func(s *smithy.Schema) error {
		switch s {
		case schemas.FairsharePolicy_computeReservation:
			v.ComputeReservation = new(int32)
			return d.ReadInt32(schemas.FairsharePolicy_computeReservation, v.ComputeReservation)
		case schemas.FairsharePolicy_shareDecaySeconds:
			v.ShareDecaySeconds = new(int32)
			return d.ReadInt32(schemas.FairsharePolicy_shareDecaySeconds, v.ShareDecaySeconds)
		case schemas.FairsharePolicy_shareDistribution:
			return deserializeShareAttributesList(d, schemas.FairsharePolicy_shareDistribution, &v.ShareDistribution)
		}
		return nil
	})
}

// The fairshare utilization for a job queue, including the number of active
// shares and top capacity utilization.
type FairshareUtilizationDetail struct {

	// The total number of active shares in the fairshare scheduling job queue that
	// are currently utilizing capacity.
	ActiveShareCount *int64

	// A list of the top 20 shares with the highest capacity utilization, ordered by
	// usage amount.
	TopCapacityUtilization []FairshareCapacityUtilization

	noSmithyDocumentSerde
}

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

func (v *FairshareUtilizationDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ActiveShareCount != nil {
		s.WriteInt64(schemas.FairshareUtilizationDetail_activeShareCount, *v.ActiveShareCount)
	}
	if v.TopCapacityUtilization != nil {
		serializeFairshareCapacityUtilizationList(s, schemas.FairshareUtilizationDetail_topCapacityUtilization, v.TopCapacityUtilization)
	}
}
func (v *FairshareUtilizationDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FairshareUtilizationDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.FairshareUtilizationDetail_activeShareCount:
			v.ActiveShareCount = new(int64)
			return d.ReadInt64(schemas.FairshareUtilizationDetail_activeShareCount, v.ActiveShareCount)
		case schemas.FairshareUtilizationDetail_topCapacityUtilization:
			return deserializeFairshareCapacityUtilizationList(d, schemas.FairshareUtilizationDetail_topCapacityUtilization, &v.TopCapacityUtilization)
		}
		return nil
	})
}

// The platform configuration for jobs that are running on Fargate resources. Jobs
// that run on Amazon EC2 resources must not specify this parameter.
type FargatePlatformConfiguration struct {

	// The Fargate platform version where the jobs are running. A platform version is
	// specified only for jobs that are running on Fargate resources. If one isn't
	// specified, the LATEST platform version is used by default. This uses a recent,
	// approved version of the Fargate platform for compute resources. For more
	// information, see [Fargate platform versions]in the Amazon Elastic Container Service Developer Guide.
	//
	// [Fargate platform versions]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html
	PlatformVersion *string

	noSmithyDocumentSerde
}

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

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

// The FireLens configuration for the container. This is used to specify and
// configure a log router for container logs. For more information, see [Custom log]routing in
// the Amazon Elastic Container Service Developer Guide.
//
// [Custom log]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html
type FirelensConfiguration struct {

	// The log router to use. The valid values are fluentd or fluentbit .
	//
	// This member is required.
	Type FirelensConfigurationType

	// The options to use when configuring the log router. This field is optional and
	// can be used to specify a custom configuration file or to add additional
	// metadata, such as the task, task definition, cluster, and container instance
	// details to the log event. If specified, the syntax to use is
	// "options":{"enable-ecs-log-metadata":"true|false","config-file-type:"s3|file","config-file-value":"arn:aws:s3:::mybucket/fluent.conf|filepath"}
	// . For more information, see [Creating a task definition that uses a FireLens configuration]in the Amazon Elastic Container Service Developer
	// Guide.
	//
	// [Creating a task definition that uses a FireLens configuration]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html#firelens-taskdef
	Options map[string]string

	noSmithyDocumentSerde
}

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

func (v *FirelensConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Options != nil {
		serializeFirelensConfigurationOptionsMap(s, schemas.FirelensConfiguration_options, v.Options)
	}
	if v.Type != "" {
		s.WriteString(schemas.FirelensConfiguration_type, string(v.Type))
	}
}
func (v *FirelensConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FirelensConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.FirelensConfiguration_options:
			return deserializeFirelensConfigurationOptionsMap(d, schemas.FirelensConfiguration_options, &v.Options)
		case schemas.FirelensConfiguration_type:
			var ev string
			if err := d.ReadString(schemas.FirelensConfiguration_type, &ev); err != nil {
				return err
			}
			v.Type = FirelensConfigurationType(ev)
			return nil
		}
		return nil
	})
}

// Contains a list of the first 100 RUNNABLE jobs associated to a single job queue.
type FrontOfQueueDetail struct {

	// The Amazon Resource Names (ARNs) of the first 100 RUNNABLE jobs in a named job
	// queue. For first-in-first-out (FIFO) job queues, jobs are ordered based on their
	// submission time. For fair-share scheduling (FSS) job queues, jobs are ordered
	// based on their job priority and share usage.
	Jobs []FrontOfQueueJobSummary

	// The Unix timestamp (in milliseconds) for when each of the first 100 RUNNABLE
	// jobs were last updated.
	LastUpdatedAt *int64

	noSmithyDocumentSerde
}

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

func (v *FrontOfQueueDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Jobs != nil {
		serializeFrontOfQueueJobSummaryList(s, schemas.FrontOfQueueDetail_jobs, v.Jobs)
	}
	if v.LastUpdatedAt != nil {
		s.WriteInt64(schemas.FrontOfQueueDetail_lastUpdatedAt, *v.LastUpdatedAt)
	}
}
func (v *FrontOfQueueDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FrontOfQueueDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.FrontOfQueueDetail_jobs:
			return deserializeFrontOfQueueJobSummaryList(d, schemas.FrontOfQueueDetail_jobs, &v.Jobs)
		case schemas.FrontOfQueueDetail_lastUpdatedAt:
			v.LastUpdatedAt = new(int64)
			return d.ReadInt64(schemas.FrontOfQueueDetail_lastUpdatedAt, v.LastUpdatedAt)
		}
		return nil
	})
}

// An object that represents summary details for the first 100 RUNNABLE jobs in a
// job queue.
type FrontOfQueueJobSummary struct {

	// The Unix timestamp (in milliseconds) for when the job transitioned to its
	// current position in the job queue.
	EarliestTimeAtPosition *int64

	// The ARN for a job in a named job queue.
	JobArn *string

	noSmithyDocumentSerde
}

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

func (v *FrontOfQueueJobSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EarliestTimeAtPosition != nil {
		s.WriteInt64(schemas.FrontOfQueueJobSummary_earliestTimeAtPosition, *v.EarliestTimeAtPosition)
	}
	if v.JobArn != nil {
		s.WriteString(schemas.FrontOfQueueJobSummary_jobArn, *v.JobArn)
	}
}
func (v *FrontOfQueueJobSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FrontOfQueueJobSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.FrontOfQueueJobSummary_earliestTimeAtPosition:
			v.EarliestTimeAtPosition = new(int64)
			return d.ReadInt64(schemas.FrontOfQueueJobSummary_earliestTimeAtPosition, v.EarliestTimeAtPosition)
		case schemas.FrontOfQueueJobSummary_jobArn:
			v.JobArn = new(string)
			return d.ReadString(schemas.FrontOfQueueJobSummary_jobArn, v.JobArn)
		}
		return nil
	})
}

// An object that represents summary details for the first RUNNABLE job in a quota
// share.
type FrontOfQuotaShareJobSummary struct {

	// The Unix timestamp (in milliseconds) for when the job transitioned to its
	// current position in the quota share.
	EarliestTimeAtPosition *int64

	// The ARN for a job in a named quota share.
	JobArn *string

	noSmithyDocumentSerde
}

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

func (v *FrontOfQuotaShareJobSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EarliestTimeAtPosition != nil {
		s.WriteInt64(schemas.FrontOfQuotaShareJobSummary_earliestTimeAtPosition, *v.EarliestTimeAtPosition)
	}
	if v.JobArn != nil {
		s.WriteString(schemas.FrontOfQuotaShareJobSummary_jobArn, *v.JobArn)
	}
}
func (v *FrontOfQuotaShareJobSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FrontOfQuotaShareJobSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.FrontOfQuotaShareJobSummary_earliestTimeAtPosition:
			v.EarliestTimeAtPosition = new(int64)
			return d.ReadInt64(schemas.FrontOfQuotaShareJobSummary_earliestTimeAtPosition, v.EarliestTimeAtPosition)
		case schemas.FrontOfQuotaShareJobSummary_jobArn:
			v.JobArn = new(string)
			return d.ReadString(schemas.FrontOfQuotaShareJobSummary_jobArn, v.JobArn)
		}
		return nil
	})
}

// An object that represents the details of the first RUNNABLE job in each named
// quota share associated with a single job queue.
type FrontOfQuotaSharesDetail struct {

	// The Unix timestamp (in milliseconds) for when the first RUNNABLE job per quota
	// share were all last updated.
	LastUpdatedAt *int64

	// Contains a list of the first RUNNABLE job in each named quota share.
	QuotaShares map[string][]FrontOfQuotaShareJobSummary

	noSmithyDocumentSerde
}

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

func (v *FrontOfQuotaSharesDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.LastUpdatedAt != nil {
		s.WriteInt64(schemas.FrontOfQuotaSharesDetail_lastUpdatedAt, *v.LastUpdatedAt)
	}
	if v.QuotaShares != nil {
		serializeFrontOfQuotaSharesJobSummaryMap(s, schemas.FrontOfQuotaSharesDetail_quotaShares, v.QuotaShares)
	}
}
func (v *FrontOfQuotaSharesDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.FrontOfQuotaSharesDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.FrontOfQuotaSharesDetail_lastUpdatedAt:
			v.LastUpdatedAt = new(int64)
			return d.ReadInt64(schemas.FrontOfQuotaSharesDetail_lastUpdatedAt, v.LastUpdatedAt)
		case schemas.FrontOfQuotaSharesDetail_quotaShares:
			return deserializeFrontOfQuotaSharesJobSummaryMap(d, schemas.FrontOfQuotaSharesDetail_quotaShares, &v.QuotaShares)
		}
		return nil
	})
}

// Determine whether your data volume persists on the host container instance and
// where it's stored. If this parameter is empty, then the Docker daemon assigns a
// host path for your data volume. However, the data isn't guaranteed to persist
// after the containers that are associated with it stop running.
type Host struct {

	// The path on the host container instance that's presented to the container. If
	// this parameter is empty, then the Docker daemon has assigned a host path for
	// you. If this parameter contains a file location, then the data volume persists
	// at the specified location on the host container instance until you delete it
	// manually. If the source path location doesn't exist on the host container
	// instance, the Docker daemon creates it. If the location does exist, the contents
	// of the source path folder are exported.
	//
	// This parameter isn't applicable to jobs that run on Fargate resources. Don't
	// provide this for these jobs.
	SourcePath *string

	noSmithyDocumentSerde
}

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

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

// References a Kubernetes secret resource. This name of the secret must start and
// end with an alphanumeric character, is required to be lowercase, can include
// periods (.) and hyphens (-), and can't contain more than 253 characters.
type ImagePullSecret struct {

	// Provides a unique identifier for the ImagePullSecret . This object is required
	// when EksPodProperties$imagePullSecrets is used.
	//
	// This member is required.
	Name *string

	noSmithyDocumentSerde
}

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

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

// The infrastructure optimization configuration for an Amazon ECS Managed
// Instances capacity provider. Specifies the idle-instance scale-in behavior.
type InfrastructureOptimization struct {

	// The number of seconds an instance can remain idle before it is terminated.
	// Valid values are -1 or 0 to 3600 . Use -1 as a special value to disable
	// scale-in (instances are never terminated for being idle). If not specified, a
	// default value applies.
	ScaleInAfter *int32

	noSmithyDocumentSerde
}

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

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

// The instance launch configuration for an Amazon ECS Managed Instances capacity
// provider. Specifies the instance profile, networking, instance selection
// constraints, capacity pricing model, storage, and monitoring settings.
type InstanceLaunchTemplate struct {

	// The Amazon Resource Name (ARN) of the Amazon EC2 instance profile for the
	// managed instances. The instance profile must use the
	// AmazonECSInstanceRolePolicyForManagedInstances managed policy with a trust
	// policy for ec2.amazonaws.com .
	//
	// This member is required.
	Ec2InstanceProfileArn *string

	// The network configuration for the managed instances. Specifies the VPC subnets
	// and security groups where instances are launched.
	//
	// This member is required.
	NetworkConfiguration *ManagedInstancesNetworkConfiguration

	// The capacity pricing model for the managed instances. Valid values:
	//
	//   - ON_DEMAND (default) — On-Demand pricing.
	//
	//   - SPOT — Spot Instances, which can provide significant cost savings for
	//   fault-tolerant workloads.
	CapacityOptionType *string

	// The capacity reservation configuration for the managed instances. Use this to
	// target On-Demand Capacity Reservations or Reserved Instances for predictable
	// capacity and cost optimization.
	CapacityReservations *CapacityReservationRequest

	// Specifies whether FIPS 140-2 validated cryptographic modules are enabled on the
	// managed instances. Not available in all Regions.
	FipsEnabled *bool

	// Specifies whether instance tags are accessible from the instance metadata
	// service (IMDS). If not specified, instance tags are not accessible from IMDS.
	InstanceMetadataTagsPropagation *bool

	// The instance type requirements for the capacity provider. Use this to constrain
	// which Amazon EC2 instance types Amazon ECS can launch. If not specified, all
	// available instance types are eligible.
	InstanceRequirements *InstanceRequirementsRequest

	// The local storage configuration for the managed instances. If not specified,
	// instance store volumes are not available to containers.
	LocalStorageConfiguration *ManagedInstancesLocalStorageConfiguration

	// The level of CloudWatch monitoring for the managed instances. Valid values are
	// BASIC and DETAILED .
	Monitoring *string

	// The storage configuration for the managed instances. Configures the root EBS
	// volume size. If not specified, the service uses the default EBS volume size for
	// the instance type.
	StorageConfiguration *ManagedInstancesStorageConfiguration

	noSmithyDocumentSerde
}

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

func (v *InstanceLaunchTemplate) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityOptionType != nil {
		s.WriteString(schemas.InstanceLaunchTemplate_capacityOptionType, *v.CapacityOptionType)
	}
	if v.CapacityReservations != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplate_capacityReservations)
		v.CapacityReservations.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Ec2InstanceProfileArn != nil {
		s.WriteString(schemas.InstanceLaunchTemplate_ec2InstanceProfileArn, *v.Ec2InstanceProfileArn)
	}
	if v.FipsEnabled != nil {
		s.WriteBool(schemas.InstanceLaunchTemplate_fipsEnabled, *v.FipsEnabled)
	}
	if v.InstanceMetadataTagsPropagation != nil {
		s.WriteBool(schemas.InstanceLaunchTemplate_instanceMetadataTagsPropagation, *v.InstanceMetadataTagsPropagation)
	}
	if v.InstanceRequirements != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplate_instanceRequirements)
		v.InstanceRequirements.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LocalStorageConfiguration != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplate_localStorageConfiguration)
		v.LocalStorageConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Monitoring != nil {
		s.WriteString(schemas.InstanceLaunchTemplate_monitoring, *v.Monitoring)
	}
	if v.NetworkConfiguration != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplate_networkConfiguration)
		v.NetworkConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.StorageConfiguration != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplate_storageConfiguration)
		v.StorageConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *InstanceLaunchTemplate) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InstanceLaunchTemplate, func(s *smithy.Schema) error {
		switch s {
		case schemas.InstanceLaunchTemplate_capacityOptionType:
			v.CapacityOptionType = new(string)
			return d.ReadString(schemas.InstanceLaunchTemplate_capacityOptionType, v.CapacityOptionType)
		case schemas.InstanceLaunchTemplate_capacityReservations:
			v.CapacityReservations = &CapacityReservationRequest{}
			return v.CapacityReservations.Deserialize(d)
		case schemas.InstanceLaunchTemplate_ec2InstanceProfileArn:
			v.Ec2InstanceProfileArn = new(string)
			return d.ReadString(schemas.InstanceLaunchTemplate_ec2InstanceProfileArn, v.Ec2InstanceProfileArn)
		case schemas.InstanceLaunchTemplate_fipsEnabled:
			v.FipsEnabled = new(bool)
			return d.ReadBool(schemas.InstanceLaunchTemplate_fipsEnabled, v.FipsEnabled)
		case schemas.InstanceLaunchTemplate_instanceMetadataTagsPropagation:
			v.InstanceMetadataTagsPropagation = new(bool)
			return d.ReadBool(schemas.InstanceLaunchTemplate_instanceMetadataTagsPropagation, v.InstanceMetadataTagsPropagation)
		case schemas.InstanceLaunchTemplate_instanceRequirements:
			v.InstanceRequirements = &InstanceRequirementsRequest{}
			return v.InstanceRequirements.Deserialize(d)
		case schemas.InstanceLaunchTemplate_localStorageConfiguration:
			v.LocalStorageConfiguration = &ManagedInstancesLocalStorageConfiguration{}
			return v.LocalStorageConfiguration.Deserialize(d)
		case schemas.InstanceLaunchTemplate_monitoring:
			v.Monitoring = new(string)
			return d.ReadString(schemas.InstanceLaunchTemplate_monitoring, v.Monitoring)
		case schemas.InstanceLaunchTemplate_networkConfiguration:
			v.NetworkConfiguration = &ManagedInstancesNetworkConfiguration{}
			return v.NetworkConfiguration.Deserialize(d)
		case schemas.InstanceLaunchTemplate_storageConfiguration:
			v.StorageConfiguration = &ManagedInstancesStorageConfiguration{}
			return v.StorageConfiguration.Deserialize(d)
		}
		return nil
	})
}

// The instance launch configuration for updating an Amazon ECS Managed Instances
// capacity provider. You cannot change capacityOptionType or fipsEnabled after
// the compute environment is created.
type InstanceLaunchTemplateUpdate struct {

	// The updated capacity reservation configuration.
	CapacityReservations *CapacityReservationRequest

	// The updated Amazon Resource Name (ARN) of the Amazon EC2 instance profile for
	// the managed instances.
	Ec2InstanceProfileArn *string

	// Specifies whether instance tags are accessible from the instance metadata
	// service (IMDS).
	InstanceMetadataTagsPropagation *bool

	// The updated instance type requirements for the capacity provider.
	InstanceRequirements *InstanceRequirementsRequest

	// The updated local storage configuration.
	LocalStorageConfiguration *ManagedInstancesLocalStorageConfiguration

	// The updated monitoring level. Valid values are BASIC and DETAILED .
	Monitoring *string

	// The updated network configuration for the managed instances.
	NetworkConfiguration *ManagedInstancesNetworkConfiguration

	// The updated storage configuration for the managed instances.
	StorageConfiguration *ManagedInstancesStorageConfiguration

	noSmithyDocumentSerde
}

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

func (v *InstanceLaunchTemplateUpdate) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityReservations != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplateUpdate_capacityReservations)
		v.CapacityReservations.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Ec2InstanceProfileArn != nil {
		s.WriteString(schemas.InstanceLaunchTemplateUpdate_ec2InstanceProfileArn, *v.Ec2InstanceProfileArn)
	}
	if v.InstanceMetadataTagsPropagation != nil {
		s.WriteBool(schemas.InstanceLaunchTemplateUpdate_instanceMetadataTagsPropagation, *v.InstanceMetadataTagsPropagation)
	}
	if v.InstanceRequirements != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplateUpdate_instanceRequirements)
		v.InstanceRequirements.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LocalStorageConfiguration != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplateUpdate_localStorageConfiguration)
		v.LocalStorageConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Monitoring != nil {
		s.WriteString(schemas.InstanceLaunchTemplateUpdate_monitoring, *v.Monitoring)
	}
	if v.NetworkConfiguration != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplateUpdate_networkConfiguration)
		v.NetworkConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.StorageConfiguration != nil {
		s.WriteStruct(schemas.InstanceLaunchTemplateUpdate_storageConfiguration)
		v.StorageConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *InstanceLaunchTemplateUpdate) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InstanceLaunchTemplateUpdate, func(s *smithy.Schema) error {
		switch s {
		case schemas.InstanceLaunchTemplateUpdate_capacityReservations:
			v.CapacityReservations = &CapacityReservationRequest{}
			return v.CapacityReservations.Deserialize(d)
		case schemas.InstanceLaunchTemplateUpdate_ec2InstanceProfileArn:
			v.Ec2InstanceProfileArn = new(string)
			return d.ReadString(schemas.InstanceLaunchTemplateUpdate_ec2InstanceProfileArn, v.Ec2InstanceProfileArn)
		case schemas.InstanceLaunchTemplateUpdate_instanceMetadataTagsPropagation:
			v.InstanceMetadataTagsPropagation = new(bool)
			return d.ReadBool(schemas.InstanceLaunchTemplateUpdate_instanceMetadataTagsPropagation, v.InstanceMetadataTagsPropagation)
		case schemas.InstanceLaunchTemplateUpdate_instanceRequirements:
			v.InstanceRequirements = &InstanceRequirementsRequest{}
			return v.InstanceRequirements.Deserialize(d)
		case schemas.InstanceLaunchTemplateUpdate_localStorageConfiguration:
			v.LocalStorageConfiguration = &ManagedInstancesLocalStorageConfiguration{}
			return v.LocalStorageConfiguration.Deserialize(d)
		case schemas.InstanceLaunchTemplateUpdate_monitoring:
			v.Monitoring = new(string)
			return d.ReadString(schemas.InstanceLaunchTemplateUpdate_monitoring, v.Monitoring)
		case schemas.InstanceLaunchTemplateUpdate_networkConfiguration:
			v.NetworkConfiguration = &ManagedInstancesNetworkConfiguration{}
			return v.NetworkConfiguration.Deserialize(d)
		case schemas.InstanceLaunchTemplateUpdate_storageConfiguration:
			v.StorageConfiguration = &ManagedInstancesStorageConfiguration{}
			return v.StorageConfiguration.Deserialize(d)
		}
		return nil
	})
}

// The instance type requirements for the Amazon ECS Managed Instances capacity
// provider. Use this to specify which Amazon EC2 instance types or instance
// families Amazon ECS can launch.
type InstanceRequirementsRequest struct {

	// A list of specific instance types or instance families that Amazon ECS can
	// launch (for example, m5.large or g5 ). When specified, only these instance types
	// are used.
	AllowedInstanceTypes []string

	noSmithyDocumentSerde
}

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

func (v *InstanceRequirementsRequest) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AllowedInstanceTypes != nil {
		serializeStringList(s, schemas.InstanceRequirementsRequest_allowedInstanceTypes, v.AllowedInstanceTypes)
	}
}
func (v *InstanceRequirementsRequest) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.InstanceRequirementsRequest, func(s *smithy.Schema) error {
		switch s {
		case schemas.InstanceRequirementsRequest_allowedInstanceTypes:
			return deserializeStringList(d, schemas.InstanceRequirementsRequest_allowedInstanceTypes, &v.AllowedInstanceTypes)
		}
		return nil
	})
}

// The capacity usage for a job, including the unit of measure and quantity of
// resources being used.
type JobCapacityUsageSummary struct {

	// The unit of measure for the capacity usage. This is VCPU for Amazon EC2 and cpu
	// for Amazon EKS.
	CapacityUnit *string

	// The quantity of capacity being used by the job, measured in the units specified
	// by capacityUnit .
	Quantity *float64

	noSmithyDocumentSerde
}

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

func (v *JobCapacityUsageSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUnit != nil {
		s.WriteString(schemas.JobCapacityUsageSummary_capacityUnit, *v.CapacityUnit)
	}
	if v.Quantity != nil {
		s.WriteFloat64(schemas.JobCapacityUsageSummary_quantity, *v.Quantity)
	}
}
func (v *JobCapacityUsageSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.JobCapacityUsageSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.JobCapacityUsageSummary_capacityUnit:
			v.CapacityUnit = new(string)
			return d.ReadString(schemas.JobCapacityUsageSummary_capacityUnit, v.CapacityUnit)
		case schemas.JobCapacityUsageSummary_quantity:
			v.Quantity = new(float64)
			return d.ReadFloat64(schemas.JobCapacityUsageSummary_quantity, v.Quantity)
		}
		return nil
	})
}

// An object that represents an Batch job definition.
type JobDefinition struct {

	// The Amazon Resource Name (ARN) for the job definition.
	//
	// This member is required.
	JobDefinitionArn *string

	// The name of the job definition.
	//
	// This member is required.
	JobDefinitionName *string

	// The revision of the job definition.
	//
	// This member is required.
	Revision *int32

	// The type of job definition. It's either container or multinode . If the job is
	// run on Fargate resources, then multinode isn't supported. For more information
	// about multi-node parallel jobs, see [Creating a multi-node parallel job definition]in the Batch User Guide.
	//
	// [Creating a multi-node parallel job definition]: https://docs.aws.amazon.com/batch/latest/userguide/multi-node-job-def.html
	//
	// This member is required.
	Type *string

	// Contains a list of consumable resources required by the job.
	ConsumableResourceProperties *ConsumableResourceProperties

	// The orchestration type of the compute environment. The valid values are ECS
	// (default) or EKS .
	ContainerOrchestrationType OrchestrationType

	// An object with properties specific to Amazon ECS-based jobs. When
	// containerProperties is used in the job definition, it can't be used in addition
	// to eksProperties , ecsProperties , or nodeProperties .
	ContainerProperties *ContainerProperties

	// An object that contains the properties for the Amazon ECS resources of a
	// job.When ecsProperties is used in the job definition, it can't be used in
	// addition to containerProperties , eksProperties , or nodeProperties .
	EcsProperties *EcsProperties

	// An object with properties that are specific to Amazon EKS-based jobs. When
	// eksProperties is used in the job definition, it can't be used in addition to
	// containerProperties , ecsProperties , or nodeProperties .
	EksProperties *EksProperties

	// An object with properties that are specific to multi-node parallel jobs. When
	// nodeProperties is used in the job definition, it can't be used in addition to
	// containerProperties , ecsProperties , or eksProperties .
	//
	// If the job runs on Fargate resources, don't specify nodeProperties . Use
	// containerProperties instead.
	NodeProperties *NodeProperties

	// Default parameters or parameter substitution placeholders that are set in the
	// job definition. Parameters are specified as a key-value pair mapping. Parameters
	// in a SubmitJob request override any corresponding parameter defaults from the
	// job definition. For more information about specifying parameters, see [Job definition parameters]in the
	// Batch User Guide.
	//
	// [Job definition parameters]: https://docs.aws.amazon.com/batch/latest/userguide/job_definition_parameters.html
	Parameters map[string]string

	// The platform capabilities required by the job definition. If no value is
	// specified, it defaults to EC2 . Jobs run on Fargate resources specify FARGATE .
	// Jobs run on Amazon ECS Managed Instances specify MANAGED_INSTANCES .
	PlatformCapabilities []PlatformCapability

	// Specifies whether to propagate the tags from the job or job definition to the
	// corresponding Amazon ECS task. If no value is specified, the tags aren't
	// propagated. Tags can only be propagated to the tasks when the tasks are created.
	// For tags with the same name, job tags are given priority over job definitions
	// tags. If the total number of combined tags from the job and job definition is
	// over 50, the job is moved to the FAILED state.
	PropagateTags *bool

	// The retry strategy to use for failed jobs that are submitted with this job
	// definition.
	RetryStrategy *RetryStrategy

	// The scheduling priority of the job definition. This only affects jobs in job
	// queues with a fair-share policy. Jobs with a higher scheduling priority are
	// scheduled before jobs with a lower scheduling priority.
	SchedulingPriority *int32

	// The status of the job definition.
	Status *string

	// The tags that are applied to the job definition.
	Tags map[string]string

	// The timeout time for jobs that are submitted with this job definition. After
	// the amount of time you specify passes, Batch terminates your jobs if they aren't
	// finished.
	Timeout *JobTimeout

	noSmithyDocumentSerde
}

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

func (v *JobDefinition) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ConsumableResourceProperties != nil {
		s.WriteStruct(schemas.JobDefinition_consumableResourceProperties)
		v.ConsumableResourceProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ContainerOrchestrationType != "" {
		s.WriteString(schemas.JobDefinition_containerOrchestrationType, string(v.ContainerOrchestrationType))
	}
	if v.ContainerProperties != nil {
		s.WriteStruct(schemas.JobDefinition_containerProperties)
		v.ContainerProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EcsProperties != nil {
		s.WriteStruct(schemas.JobDefinition_ecsProperties)
		v.EcsProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EksProperties != nil {
		s.WriteStruct(schemas.JobDefinition_eksProperties)
		v.EksProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.JobDefinitionArn != nil {
		s.WriteString(schemas.JobDefinition_jobDefinitionArn, *v.JobDefinitionArn)
	}
	if v.JobDefinitionName != nil {
		s.WriteString(schemas.JobDefinition_jobDefinitionName, *v.JobDefinitionName)
	}
	if v.NodeProperties != nil {
		s.WriteStruct(schemas.JobDefinition_nodeProperties)
		v.NodeProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Parameters != nil {
		serializeParametersMap(s, schemas.JobDefinition_parameters, v.Parameters)
	}
	if v.PlatformCapabilities != nil {
		serializePlatformCapabilityList(s, schemas.JobDefinition_platformCapabilities, v.PlatformCapabilities)
	}
	if v.PropagateTags != nil {
		s.WriteBool(schemas.JobDefinition_propagateTags, *v.PropagateTags)
	}
	if v.RetryStrategy != nil {
		s.WriteStruct(schemas.JobDefinition_retryStrategy)
		v.RetryStrategy.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Revision != nil {
		s.WriteInt32(schemas.JobDefinition_revision, *v.Revision)
	}
	if v.SchedulingPriority != nil {
		s.WriteInt32(schemas.JobDefinition_schedulingPriority, *v.SchedulingPriority)
	}
	if v.Status != nil {
		s.WriteString(schemas.JobDefinition_status, *v.Status)
	}
	if v.Tags != nil {
		serializeTagrisTagsMap(s, schemas.JobDefinition_tags, v.Tags)
	}
	if v.Timeout != nil {
		s.WriteStruct(schemas.JobDefinition_timeout)
		v.Timeout.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Type != nil {
		s.WriteString(schemas.JobDefinition_type, *v.Type)
	}
}
func (v *JobDefinition) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.JobDefinition, func(s *smithy.Schema) error {
		switch s {
		case schemas.JobDefinition_consumableResourceProperties:
			v.ConsumableResourceProperties = &ConsumableResourceProperties{}
			return v.ConsumableResourceProperties.Deserialize(d)
		case schemas.JobDefinition_containerOrchestrationType:
			var ev string
			if err := d.ReadString(schemas.JobDefinition_containerOrchestrationType, &ev); err != nil {
				return err
			}
			v.ContainerOrchestrationType = OrchestrationType(ev)
			return nil
		case schemas.JobDefinition_containerProperties:
			v.ContainerProperties = &ContainerProperties{}
			return v.ContainerProperties.Deserialize(d)
		case schemas.JobDefinition_ecsProperties:
			v.EcsProperties = &EcsProperties{}
			return v.EcsProperties.Deserialize(d)
		case schemas.JobDefinition_eksProperties:
			v.EksProperties = &EksProperties{}
			return v.EksProperties.Deserialize(d)
		case schemas.JobDefinition_jobDefinitionArn:
			v.JobDefinitionArn = new(string)
			return d.ReadString(schemas.JobDefinition_jobDefinitionArn, v.JobDefinitionArn)
		case schemas.JobDefinition_jobDefinitionName:
			v.JobDefinitionName = new(string)
			return d.ReadString(schemas.JobDefinition_jobDefinitionName, v.JobDefinitionName)
		case schemas.JobDefinition_nodeProperties:
			v.NodeProperties = &NodeProperties{}
			return v.NodeProperties.Deserialize(d)
		case schemas.JobDefinition_parameters:
			return deserializeParametersMap(d, schemas.JobDefinition_parameters, &v.Parameters)
		case schemas.JobDefinition_platformCapabilities:
			return deserializePlatformCapabilityList(d, schemas.JobDefinition_platformCapabilities, &v.PlatformCapabilities)
		case schemas.JobDefinition_propagateTags:
			v.PropagateTags = new(bool)
			return d.ReadBool(schemas.JobDefinition_propagateTags, v.PropagateTags)
		case schemas.JobDefinition_retryStrategy:
			v.RetryStrategy = &RetryStrategy{}
			return v.RetryStrategy.Deserialize(d)
		case schemas.JobDefinition_revision:
			v.Revision = new(int32)
			return d.ReadInt32(schemas.JobDefinition_revision, v.Revision)
		case schemas.JobDefinition_schedulingPriority:
			v.SchedulingPriority = new(int32)
			return d.ReadInt32(schemas.JobDefinition_schedulingPriority, v.SchedulingPriority)
		case schemas.JobDefinition_status:
			v.Status = new(string)
			return d.ReadString(schemas.JobDefinition_status, v.Status)
		case schemas.JobDefinition_tags:
			return deserializeTagrisTagsMap(d, schemas.JobDefinition_tags, &v.Tags)
		case schemas.JobDefinition_timeout:
			v.Timeout = &JobTimeout{}
			return v.Timeout.Deserialize(d)
		case schemas.JobDefinition_type:
			v.Type = new(string)
			return d.ReadString(schemas.JobDefinition_type, v.Type)
		}
		return nil
	})
}

// An object that represents an Batch job dependency.
type JobDependency struct {

	// The job ID of the Batch job that's associated with this dependency.
	JobId *string

	// The type of the job dependency.
	Type ArrayJobDependency

	noSmithyDocumentSerde
}

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

func (v *JobDependency) SerializeMembers(s smithy.ShapeSerializer) {
	if v.JobId != nil {
		s.WriteString(schemas.JobDependency_jobId, *v.JobId)
	}
	if v.Type != "" {
		s.WriteString(schemas.JobDependency_type, string(v.Type))
	}
}
func (v *JobDependency) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.JobDependency, func(s *smithy.Schema) error {
		switch s {
		case schemas.JobDependency_jobId:
			v.JobId = new(string)
			return d.ReadString(schemas.JobDependency_jobId, v.JobId)
		case schemas.JobDependency_type:
			var ev string
			if err := d.ReadString(schemas.JobDependency_type, &ev); err != nil {
				return err
			}
			v.Type = ArrayJobDependency(ev)
			return nil
		}
		return nil
	})
}

// An object that represents an Batch job.
type JobDetail struct {

	// The Amazon Resource Name (ARN) of the job definition that this job uses.
	//
	// This member is required.
	JobDefinition *string

	// The job ID.
	//
	// This member is required.
	JobId *string

	// The job name.
	//
	// This member is required.
	JobName *string

	// The Amazon Resource Name (ARN) of the job queue that the job is associated with.
	//
	// This member is required.
	JobQueue *string

	// The Unix timestamp (in milliseconds) for when the job was started. More
	// specifically, it's when the job transitioned from the STARTING state to the
	// RUNNING state.
	//
	// This member is required.
	StartedAt *int64

	// The current status for the job.
	//
	// If your jobs don't progress to STARTING , see [Jobs stuck in RUNNABLE status] in the troubleshooting section
	// of the Batch User Guide.
	//
	// [Jobs stuck in RUNNABLE status]: https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#job_stuck_in_runnable
	//
	// This member is required.
	Status JobStatus

	// The array properties of the job, if it's an array job.
	ArrayProperties *ArrayPropertiesDetail

	// A list of job attempts that are associated with this job.
	Attempts []AttemptDetail

	// Contains a list of consumable resources required by the job.
	ConsumableResourceProperties *ConsumableResourceProperties

	// An object that represents the details for the container that's associated with
	// the job. If the details are for a multiple-container job, this object will be
	// empty.
	Container *ContainerDetail

	// The Unix timestamp (in milliseconds) for when the job was created. For
	// non-array jobs and parent array jobs, this is when the job entered the SUBMITTED
	// state. This is specifically at the time [SubmitJob]was called. For array child jobs, this
	// is when the child job was spawned by its parent and entered the PENDING state.
	//
	// [SubmitJob]: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html
	CreatedAt *int64

	// A list of job IDs that this job depends on.
	DependsOn []JobDependency

	// An object with properties that are specific to Amazon ECS-based jobs.
	EcsProperties *EcsPropertiesDetail

	// A list of job attempts that are associated with this job.
	EksAttempts []EksAttemptDetail

	// An object with various properties that are specific to Amazon EKS based jobs.
	EksProperties *EksPropertiesDetail

	// Indicates whether the job is cancelled.
	IsCancelled *bool

	// Indicates whether the job is terminated.
	IsTerminated *bool

	// The Amazon Resource Name (ARN) of the job.
	JobArn *string

	// An object that represents the details of a node that's associated with a
	// multi-node parallel job.
	NodeDetails *NodeDetails

	// An object that represents the node properties of a multi-node parallel job.
	//
	// This isn't applicable to jobs that are running on Fargate resources.
	NodeProperties *NodeProperties

	// Additional parameters that are passed to the job that replace parameter
	// substitution placeholders or override any corresponding parameter defaults from
	// the job definition.
	Parameters map[string]string

	// The platform capabilities required by the job definition. If no value is
	// specified, it defaults to EC2 . Jobs run on Fargate resources specify FARGATE .
	// Jobs run on Amazon ECS Managed Instances specify MANAGED_INSTANCES .
	PlatformCapabilities []PlatformCapability

	// Specifies whether to propagate the tags from the job or job definition to the
	// corresponding Amazon ECS task. If no value is specified, the tags aren't
	// propagated. Tags can only be propagated to the tasks when the tasks are created.
	// For tags with the same name, job tags are given priority over job definitions
	// tags. If the total number of combined tags from the job and job definition is
	// over 50, the job is moved to the FAILED state.
	PropagateTags *bool

	// The retry strategy to use for this job if an attempt fails.
	RetryStrategy *RetryStrategy

	// The scheduling policy of the job definition. This only affects jobs in job
	// queues with a fair-share policy. Jobs with a higher scheduling priority are
	// scheduled before jobs with a lower scheduling priority.
	SchedulingPriority *int32

	// The share identifier for the job.
	ShareIdentifier *string

	// A short, human-readable string to provide more details for the current status
	// of the job.
	//
	//   - CAPACITY:INSUFFICIENT_INSTANCE_CAPACITY - All compute environments have
	//   insufficient capacity to service the job.
	//
	//   - MISCONFIGURATION:COMPUTE_ENVIRONMENT_MAX_RESOURCE - All compute environments
	//   have a maxVcpu setting that is smaller than the job requirements.
	//
	//   - MISCONFIGURATION:JOB_RESOURCE_REQUIREMENT - All compute environments have no
	//   connected instances that meet the job requirements.
	//
	//   - MISCONFIGURATION:SERVICE_ROLE_PERMISSIONS - All compute environments have
	//   problems with the service role permissions.
	StatusReason *string

	// The Unix timestamp (in milliseconds) for when the job was stopped. More
	// specifically, it's when the job transitioned from the RUNNING state to a
	// terminal state, such as SUCCEEDED or FAILED .
	StoppedAt *int64

	// The tags that are applied to the job.
	Tags map[string]string

	// The timeout configuration for the job.
	Timeout *JobTimeout

	noSmithyDocumentSerde
}

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

func (v *JobDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ArrayProperties != nil {
		s.WriteStruct(schemas.JobDetail_arrayProperties)
		v.ArrayProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Attempts != nil {
		serializeAttemptDetails(s, schemas.JobDetail_attempts, v.Attempts)
	}
	if v.ConsumableResourceProperties != nil {
		s.WriteStruct(schemas.JobDetail_consumableResourceProperties)
		v.ConsumableResourceProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Container != nil {
		s.WriteStruct(schemas.JobDetail_container)
		v.Container.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CreatedAt != nil {
		s.WriteInt64(schemas.JobDetail_createdAt, *v.CreatedAt)
	}
	if v.DependsOn != nil {
		serializeJobDependencyList(s, schemas.JobDetail_dependsOn, v.DependsOn)
	}
	if v.EcsProperties != nil {
		s.WriteStruct(schemas.JobDetail_ecsProperties)
		v.EcsProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EksAttempts != nil {
		serializeEksAttemptDetails(s, schemas.JobDetail_eksAttempts, v.EksAttempts)
	}
	if v.EksProperties != nil {
		s.WriteStruct(schemas.JobDetail_eksProperties)
		v.EksProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.IsCancelled != nil {
		s.WriteBool(schemas.JobDetail_isCancelled, *v.IsCancelled)
	}
	if v.IsTerminated != nil {
		s.WriteBool(schemas.JobDetail_isTerminated, *v.IsTerminated)
	}
	if v.JobArn != nil {
		s.WriteString(schemas.JobDetail_jobArn, *v.JobArn)
	}
	if v.JobDefinition != nil {
		s.WriteString(schemas.JobDetail_jobDefinition, *v.JobDefinition)
	}
	if v.JobId != nil {
		s.WriteString(schemas.JobDetail_jobId, *v.JobId)
	}
	if v.JobName != nil {
		s.WriteString(schemas.JobDetail_jobName, *v.JobName)
	}
	if v.JobQueue != nil {
		s.WriteString(schemas.JobDetail_jobQueue, *v.JobQueue)
	}
	if v.NodeDetails != nil {
		s.WriteStruct(schemas.JobDetail_nodeDetails)
		v.NodeDetails.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.NodeProperties != nil {
		s.WriteStruct(schemas.JobDetail_nodeProperties)
		v.NodeProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Parameters != nil {
		serializeParametersMap(s, schemas.JobDetail_parameters, v.Parameters)
	}
	if v.PlatformCapabilities != nil {
		serializePlatformCapabilityList(s, schemas.JobDetail_platformCapabilities, v.PlatformCapabilities)
	}
	if v.PropagateTags != nil {
		s.WriteBool(schemas.JobDetail_propagateTags, *v.PropagateTags)
	}
	if v.RetryStrategy != nil {
		s.WriteStruct(schemas.JobDetail_retryStrategy)
		v.RetryStrategy.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.SchedulingPriority != nil {
		s.WriteInt32(schemas.JobDetail_schedulingPriority, *v.SchedulingPriority)
	}
	if v.ShareIdentifier != nil {
		s.WriteString(schemas.JobDetail_shareIdentifier, *v.ShareIdentifier)
	}
	if v.StartedAt != nil {
		s.WriteInt64(schemas.JobDetail_startedAt, *v.StartedAt)
	}
	if v.Status != "" {
		s.WriteString(schemas.JobDetail_status, string(v.Status))
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.JobDetail_statusReason, *v.StatusReason)
	}
	if v.StoppedAt != nil {
		s.WriteInt64(schemas.JobDetail_stoppedAt, *v.StoppedAt)
	}
	if v.Tags != nil {
		serializeTagrisTagsMap(s, schemas.JobDetail_tags, v.Tags)
	}
	if v.Timeout != nil {
		s.WriteStruct(schemas.JobDetail_timeout)
		v.Timeout.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *JobDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.JobDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.JobDetail_arrayProperties:
			v.ArrayProperties = &ArrayPropertiesDetail{}
			return v.ArrayProperties.Deserialize(d)
		case schemas.JobDetail_attempts:
			return deserializeAttemptDetails(d, schemas.JobDetail_attempts, &v.Attempts)
		case schemas.JobDetail_consumableResourceProperties:
			v.ConsumableResourceProperties = &ConsumableResourceProperties{}
			return v.ConsumableResourceProperties.Deserialize(d)
		case schemas.JobDetail_container:
			v.Container = &ContainerDetail{}
			return v.Container.Deserialize(d)
		case schemas.JobDetail_createdAt:
			v.CreatedAt = new(int64)
			return d.ReadInt64(schemas.JobDetail_createdAt, v.CreatedAt)
		case schemas.JobDetail_dependsOn:
			return deserializeJobDependencyList(d, schemas.JobDetail_dependsOn, &v.DependsOn)
		case schemas.JobDetail_ecsProperties:
			v.EcsProperties = &EcsPropertiesDetail{}
			return v.EcsProperties.Deserialize(d)
		case schemas.JobDetail_eksAttempts:
			return deserializeEksAttemptDetails(d, schemas.JobDetail_eksAttempts, &v.EksAttempts)
		case schemas.JobDetail_eksProperties:
			v.EksProperties = &EksPropertiesDetail{}
			return v.EksProperties.Deserialize(d)
		case schemas.JobDetail_isCancelled:
			v.IsCancelled = new(bool)
			return d.ReadBool(schemas.JobDetail_isCancelled, v.IsCancelled)
		case schemas.JobDetail_isTerminated:
			v.IsTerminated = new(bool)
			return d.ReadBool(schemas.JobDetail_isTerminated, v.IsTerminated)
		case schemas.JobDetail_jobArn:
			v.JobArn = new(string)
			return d.ReadString(schemas.JobDetail_jobArn, v.JobArn)
		case schemas.JobDetail_jobDefinition:
			v.JobDefinition = new(string)
			return d.ReadString(schemas.JobDetail_jobDefinition, v.JobDefinition)
		case schemas.JobDetail_jobId:
			v.JobId = new(string)
			return d.ReadString(schemas.JobDetail_jobId, v.JobId)
		case schemas.JobDetail_jobName:
			v.JobName = new(string)
			return d.ReadString(schemas.JobDetail_jobName, v.JobName)
		case schemas.JobDetail_jobQueue:
			v.JobQueue = new(string)
			return d.ReadString(schemas.JobDetail_jobQueue, v.JobQueue)
		case schemas.JobDetail_nodeDetails:
			v.NodeDetails = &NodeDetails{}
			return v.NodeDetails.Deserialize(d)
		case schemas.JobDetail_nodeProperties:
			v.NodeProperties = &NodeProperties{}
			return v.NodeProperties.Deserialize(d)
		case schemas.JobDetail_parameters:
			return deserializeParametersMap(d, schemas.JobDetail_parameters, &v.Parameters)
		case schemas.JobDetail_platformCapabilities:
			return deserializePlatformCapabilityList(d, schemas.JobDetail_platformCapabilities, &v.PlatformCapabilities)
		case schemas.JobDetail_propagateTags:
			v.PropagateTags = new(bool)
			return d.ReadBool(schemas.JobDetail_propagateTags, v.PropagateTags)
		case schemas.JobDetail_retryStrategy:
			v.RetryStrategy = &RetryStrategy{}
			return v.RetryStrategy.Deserialize(d)
		case schemas.JobDetail_schedulingPriority:
			v.SchedulingPriority = new(int32)
			return d.ReadInt32(schemas.JobDetail_schedulingPriority, v.SchedulingPriority)
		case schemas.JobDetail_shareIdentifier:
			v.ShareIdentifier = new(string)
			return d.ReadString(schemas.JobDetail_shareIdentifier, v.ShareIdentifier)
		case schemas.JobDetail_startedAt:
			v.StartedAt = new(int64)
			return d.ReadInt64(schemas.JobDetail_startedAt, v.StartedAt)
		case schemas.JobDetail_status:
			var ev string
			if err := d.ReadString(schemas.JobDetail_status, &ev); err != nil {
				return err
			}
			v.Status = JobStatus(ev)
			return nil
		case schemas.JobDetail_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.JobDetail_statusReason, v.StatusReason)
		case schemas.JobDetail_stoppedAt:
			v.StoppedAt = new(int64)
			return d.ReadInt64(schemas.JobDetail_stoppedAt, v.StoppedAt)
		case schemas.JobDetail_tags:
			return deserializeTagrisTagsMap(d, schemas.JobDetail_tags, &v.Tags)
		case schemas.JobDetail_timeout:
			v.Timeout = &JobTimeout{}
			return v.Timeout.Deserialize(d)
		}
		return nil
	})
}

// An object that represents the details for an Batch job queue.
type JobQueueDetail struct {

	// The compute environments that are attached to the job queue and the order that
	// job placement is preferred. Compute environments are selected for job placement
	// in ascending order.
	//
	// This member is required.
	ComputeEnvironmentOrder []ComputeEnvironmentOrder

	// The Amazon Resource Name (ARN) of the job queue.
	//
	// This member is required.
	JobQueueArn *string

	// The job queue name.
	//
	// This member is required.
	JobQueueName *string

	// The priority of the job queue. Job queue priority determines the order that job
	// queues are evaluated when multiple queues dispatch jobs within a shared compute
	// environment. A higher value for priority indicates a higher priority. Queues
	// are evaluated in cycles, in descending order by priority. For example, a job
	// queue with a priority value of 10 is evaluated before a queue with a priority
	// value of 1 . All of the compute environments must be either Amazon EC2 ( EC2 or
	// SPOT ) or Fargate ( FARGATE or FARGATE_SPOT ). Amazon EC2 and Fargate compute
	// environments can't be mixed.
	//
	// Job queue priority doesn't guarantee that a particular job executes before a
	// job in a lower priority queue. Jobs added to higher priority queues during the
	// queue evaluation cycle might not be evaluated until the next cycle. A job is
	// dispatched from a queue only if resources are available when the queue is
	// evaluated. If there are insufficient resources available at that time, the cycle
	// proceeds to the next queue. This means that jobs added to higher priority queues
	// might have to wait for jobs in multiple lower priority queues to complete before
	// they are dispatched. You can use job dependencies to control the order for jobs
	// from queues with different priorities. For more information, see [Job Dependencies]in the Batch
	// User Guide.
	//
	// [Job Dependencies]: https://docs.aws.amazon.com/batch/latest/userguide/job_dependencies.html
	//
	// This member is required.
	Priority *int32

	// Describes the ability of the queue to accept new jobs. If the job queue state
	// is ENABLED , it can accept jobs. If the job queue state is DISABLED , new jobs
	// can't be added to the queue, but jobs already in the queue can finish.
	//
	// This member is required.
	State JQState

	// The type of job queue. For service jobs that run on SageMaker Training, this
	// value is SAGEMAKER_TRAINING . For regular container jobs, this value is EKS ,
	// ECS , or ECS_FARGATE depending on the compute environment.
	JobQueueType JobQueueType

	// The set of actions that Batch perform on jobs that remain at the head of the
	// job queue in the specified state longer than specified times. Batch will perform
	// each action after maxTimeSeconds has passed.
	JobStateTimeLimitActions []JobStateTimeLimitAction

	// The Amazon Resource Name (ARN) of the scheduling policy. The format is
	// aws:Partition:batch:Region:Account:scheduling-policy/Name . For example,
	// aws:aws:batch:us-west-2:123456789012:scheduling-policy/MySchedulingPolicy .
	SchedulingPolicyArn *string

	// The order of the service environment associated with the job queue. Job queues
	// with a higher priority are evaluated first when associated with the same service
	// environment.
	ServiceEnvironmentOrder []ServiceEnvironmentOrder

	// The status of the job queue (for example, CREATING or VALID ).
	Status JQStatus

	// A short, human-readable string to provide additional details for the current
	// status of the job queue.
	StatusReason *string

	// The tags that are applied to the job queue. For more information, see [Tagging your Batch resources] in Batch
	// User Guide.
	//
	// [Tagging your Batch resources]: https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html
	Tags map[string]string

	noSmithyDocumentSerde
}

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

func (v *JobQueueDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ComputeEnvironmentOrder != nil {
		serializeComputeEnvironmentOrders(s, schemas.JobQueueDetail_computeEnvironmentOrder, v.ComputeEnvironmentOrder)
	}
	if v.JobQueueArn != nil {
		s.WriteString(schemas.JobQueueDetail_jobQueueArn, *v.JobQueueArn)
	}
	if v.JobQueueName != nil {
		s.WriteString(schemas.JobQueueDetail_jobQueueName, *v.JobQueueName)
	}
	if v.JobQueueType != "" {
		s.WriteString(schemas.JobQueueDetail_jobQueueType, string(v.JobQueueType))
	}
	if v.JobStateTimeLimitActions != nil {
		serializeJobStateTimeLimitActions(s, schemas.JobQueueDetail_jobStateTimeLimitActions, v.JobStateTimeLimitActions)
	}
	if v.Priority != nil {
		s.WriteInt32(schemas.JobQueueDetail_priority, *v.Priority)
	}
	if v.SchedulingPolicyArn != nil {
		s.WriteString(schemas.JobQueueDetail_schedulingPolicyArn, *v.SchedulingPolicyArn)
	}
	if v.ServiceEnvironmentOrder != nil {
		serializeServiceEnvironmentOrders(s, schemas.JobQueueDetail_serviceEnvironmentOrder, v.ServiceEnvironmentOrder)
	}
	if v.State != "" {
		s.WriteString(schemas.JobQueueDetail_state, string(v.State))
	}
	if v.Status != "" {
		s.WriteString(schemas.JobQueueDetail_status, string(v.Status))
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.JobQueueDetail_statusReason, *v.StatusReason)
	}
	if v.Tags != nil {
		serializeTagrisTagsMap(s, schemas.JobQueueDetail_tags, v.Tags)
	}
}
func (v *JobQueueDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.JobQueueDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.JobQueueDetail_computeEnvironmentOrder:
			return deserializeComputeEnvironmentOrders(d, schemas.JobQueueDetail_computeEnvironmentOrder, &v.ComputeEnvironmentOrder)
		case schemas.JobQueueDetail_jobQueueArn:
			v.JobQueueArn = new(string)
			return d.ReadString(schemas.JobQueueDetail_jobQueueArn, v.JobQueueArn)
		case schemas.JobQueueDetail_jobQueueName:
			v.JobQueueName = new(string)
			return d.ReadString(schemas.JobQueueDetail_jobQueueName, v.JobQueueName)
		case schemas.JobQueueDetail_jobQueueType:
			var ev string
			if err := d.ReadString(schemas.JobQueueDetail_jobQueueType, &ev); err != nil {
				return err
			}
			v.JobQueueType = JobQueueType(ev)
			return nil
		case schemas.JobQueueDetail_jobStateTimeLimitActions:
			return deserializeJobStateTimeLimitActions(d, schemas.JobQueueDetail_jobStateTimeLimitActions, &v.JobStateTimeLimitActions)
		case schemas.JobQueueDetail_priority:
			v.Priority = new(int32)
			return d.ReadInt32(schemas.JobQueueDetail_priority, v.Priority)
		case schemas.JobQueueDetail_schedulingPolicyArn:
			v.SchedulingPolicyArn = new(string)
			return d.ReadString(schemas.JobQueueDetail_schedulingPolicyArn, v.SchedulingPolicyArn)
		case schemas.JobQueueDetail_serviceEnvironmentOrder:
			return deserializeServiceEnvironmentOrders(d, schemas.JobQueueDetail_serviceEnvironmentOrder, &v.ServiceEnvironmentOrder)
		case schemas.JobQueueDetail_state:
			var ev string
			if err := d.ReadString(schemas.JobQueueDetail_state, &ev); err != nil {
				return err
			}
			v.State = JQState(ev)
			return nil
		case schemas.JobQueueDetail_status:
			var ev string
			if err := d.ReadString(schemas.JobQueueDetail_status, &ev); err != nil {
				return err
			}
			v.Status = JQStatus(ev)
			return nil
		case schemas.JobQueueDetail_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.JobQueueDetail_statusReason, v.StatusReason)
		case schemas.JobQueueDetail_tags:
			return deserializeTagrisTagsMap(d, schemas.JobQueueDetail_tags, &v.Tags)
		}
		return nil
	})
}

// Specifies an action that Batch will take after the job has remained at the head
// of the queue in the specified state for longer than the specified time.
type JobStateTimeLimitAction struct {

	// The action to take when a job is at the head of the job queue in the specified
	// state for the specified period of time. For job queues connected to a ECS ,
	// FARGATE or EKS compute environment, the only supported value is CANCEL , which
	// will cancel the job. For job queues connected to a SAGEMAKER_TRAINING service
	// environment, the only supported value is TERMINATE , which will terminate the
	// job.
	//
	// This member is required.
	Action JobStateTimeLimitActionsAction

	// The approximate amount of time, in seconds, that must pass with the job in the
	// specified state before the action is taken. The minimum value is 600 (10
	// minutes) and the maximum value is 86,400 (24 hours).
	//
	// This member is required.
	MaxTimeSeconds *int32

	// The reason to log for the action being taken.
	//
	// This member is required.
	Reason *string

	// The state of the job needed to trigger the action. The only supported value is
	// RUNNABLE .
	//
	// This member is required.
	State JobStateTimeLimitActionsState

	noSmithyDocumentSerde
}

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

func (v *JobStateTimeLimitAction) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Action != "" {
		s.WriteString(schemas.JobStateTimeLimitAction_action, string(v.Action))
	}
	if v.MaxTimeSeconds != nil {
		s.WriteInt32(schemas.JobStateTimeLimitAction_maxTimeSeconds, *v.MaxTimeSeconds)
	}
	if v.Reason != nil {
		s.WriteString(schemas.JobStateTimeLimitAction_reason, *v.Reason)
	}
	if v.State != "" {
		s.WriteString(schemas.JobStateTimeLimitAction_state, string(v.State))
	}
}
func (v *JobStateTimeLimitAction) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.JobStateTimeLimitAction, func(s *smithy.Schema) error {
		switch s {
		case schemas.JobStateTimeLimitAction_action:
			var ev string
			if err := d.ReadString(schemas.JobStateTimeLimitAction_action, &ev); err != nil {
				return err
			}
			v.Action = JobStateTimeLimitActionsAction(ev)
			return nil
		case schemas.JobStateTimeLimitAction_maxTimeSeconds:
			v.MaxTimeSeconds = new(int32)
			return d.ReadInt32(schemas.JobStateTimeLimitAction_maxTimeSeconds, v.MaxTimeSeconds)
		case schemas.JobStateTimeLimitAction_reason:
			v.Reason = new(string)
			return d.ReadString(schemas.JobStateTimeLimitAction_reason, v.Reason)
		case schemas.JobStateTimeLimitAction_state:
			var ev string
			if err := d.ReadString(schemas.JobStateTimeLimitAction_state, &ev); err != nil {
				return err
			}
			v.State = JobStateTimeLimitActionsState(ev)
			return nil
		}
		return nil
	})
}

// An object that represents summary details of a job.
type JobSummary struct {

	// The job ID.
	//
	// This member is required.
	JobId *string

	// The job name.
	//
	// This member is required.
	JobName *string

	// The array properties of the job, if it's an array job.
	ArrayProperties *ArrayPropertiesSummary

	// The configured capacity usage information for this job, including the unit of
	// measure and quantity of resources.
	CapacityUsage []JobCapacityUsageSummary

	// An object that represents the details of the container that's associated with
	// the job.
	Container *ContainerSummary

	// The Unix timestamp (in milliseconds) for when the job was created. For
	// non-array jobs and parent array jobs, this is when the job entered the SUBMITTED
	// state (at the time [SubmitJob]was called). For array child jobs, this is when the child
	// job was spawned by its parent and entered the PENDING state.
	//
	// [SubmitJob]: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html
	CreatedAt *int64

	// Indicates whether a cancellation request has been accepted for the job. This
	// field is only present when the value is true .
	IsCancelled *bool

	// Indicates whether a termination request has been accepted for the job. This
	// field is only present when the value is true .
	IsTerminated *bool

	// The Amazon Resource Name (ARN) of the job.
	JobArn *string

	// The Amazon Resource Name (ARN) of the job definition.
	JobDefinition *string

	// The node properties for a single node in a job summary list.
	//
	// This isn't applicable to jobs that are running on Fargate resources.
	NodeProperties *NodePropertiesSummary

	// The Unix timestamp (in milliseconds) for when the job was scheduled for
	// execution. For more information on job statues, see [Service job status]in the Batch User Guide.
	//
	// [Service job status]: https://docs.aws.amazon.com/batch/latest/userguide/service-job-status.html
	ScheduledAt *int64

	// The share identifier for the fairshare scheduling queue that this job is
	// associated with.
	ShareIdentifier *string

	// The Unix timestamp for when the job was started. More specifically, it's when
	// the job transitioned from the STARTING state to the RUNNING state.
	StartedAt *int64

	// The current status for the job.
	Status JobStatus

	// A short, human-readable string to provide more details for the current status
	// of the job.
	StatusReason *string

	// The Unix timestamp for when the job was stopped. More specifically, it's when
	// the job transitioned from the RUNNING state to a terminal state, such as
	// SUCCEEDED or FAILED .
	StoppedAt *int64

	noSmithyDocumentSerde
}

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

func (v *JobSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ArrayProperties != nil {
		s.WriteStruct(schemas.JobSummary_arrayProperties)
		v.ArrayProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CapacityUsage != nil {
		serializeJobCapacityUsageSummaryList(s, schemas.JobSummary_capacityUsage, v.CapacityUsage)
	}
	if v.Container != nil {
		s.WriteStruct(schemas.JobSummary_container)
		v.Container.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CreatedAt != nil {
		s.WriteInt64(schemas.JobSummary_createdAt, *v.CreatedAt)
	}
	if v.IsCancelled != nil {
		s.WriteBool(schemas.JobSummary_isCancelled, *v.IsCancelled)
	}
	if v.IsTerminated != nil {
		s.WriteBool(schemas.JobSummary_isTerminated, *v.IsTerminated)
	}
	if v.JobArn != nil {
		s.WriteString(schemas.JobSummary_jobArn, *v.JobArn)
	}
	if v.JobDefinition != nil {
		s.WriteString(schemas.JobSummary_jobDefinition, *v.JobDefinition)
	}
	if v.JobId != nil {
		s.WriteString(schemas.JobSummary_jobId, *v.JobId)
	}
	if v.JobName != nil {
		s.WriteString(schemas.JobSummary_jobName, *v.JobName)
	}
	if v.NodeProperties != nil {
		s.WriteStruct(schemas.JobSummary_nodeProperties)
		v.NodeProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ScheduledAt != nil {
		s.WriteInt64(schemas.JobSummary_scheduledAt, *v.ScheduledAt)
	}
	if v.ShareIdentifier != nil {
		s.WriteString(schemas.JobSummary_shareIdentifier, *v.ShareIdentifier)
	}
	if v.StartedAt != nil {
		s.WriteInt64(schemas.JobSummary_startedAt, *v.StartedAt)
	}
	if v.Status != "" {
		s.WriteString(schemas.JobSummary_status, string(v.Status))
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.JobSummary_statusReason, *v.StatusReason)
	}
	if v.StoppedAt != nil {
		s.WriteInt64(schemas.JobSummary_stoppedAt, *v.StoppedAt)
	}
}
func (v *JobSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.JobSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.JobSummary_arrayProperties:
			v.ArrayProperties = &ArrayPropertiesSummary{}
			return v.ArrayProperties.Deserialize(d)
		case schemas.JobSummary_capacityUsage:
			return deserializeJobCapacityUsageSummaryList(d, schemas.JobSummary_capacityUsage, &v.CapacityUsage)
		case schemas.JobSummary_container:
			v.Container = &ContainerSummary{}
			return v.Container.Deserialize(d)
		case schemas.JobSummary_createdAt:
			v.CreatedAt = new(int64)
			return d.ReadInt64(schemas.JobSummary_createdAt, v.CreatedAt)
		case schemas.JobSummary_isCancelled:
			v.IsCancelled = new(bool)
			return d.ReadBool(schemas.JobSummary_isCancelled, v.IsCancelled)
		case schemas.JobSummary_isTerminated:
			v.IsTerminated = new(bool)
			return d.ReadBool(schemas.JobSummary_isTerminated, v.IsTerminated)
		case schemas.JobSummary_jobArn:
			v.JobArn = new(string)
			return d.ReadString(schemas.JobSummary_jobArn, v.JobArn)
		case schemas.JobSummary_jobDefinition:
			v.JobDefinition = new(string)
			return d.ReadString(schemas.JobSummary_jobDefinition, v.JobDefinition)
		case schemas.JobSummary_jobId:
			v.JobId = new(string)
			return d.ReadString(schemas.JobSummary_jobId, v.JobId)
		case schemas.JobSummary_jobName:
			v.JobName = new(string)
			return d.ReadString(schemas.JobSummary_jobName, v.JobName)
		case schemas.JobSummary_nodeProperties:
			v.NodeProperties = &NodePropertiesSummary{}
			return v.NodeProperties.Deserialize(d)
		case schemas.JobSummary_scheduledAt:
			v.ScheduledAt = new(int64)
			return d.ReadInt64(schemas.JobSummary_scheduledAt, v.ScheduledAt)
		case schemas.JobSummary_shareIdentifier:
			v.ShareIdentifier = new(string)
			return d.ReadString(schemas.JobSummary_shareIdentifier, v.ShareIdentifier)
		case schemas.JobSummary_startedAt:
			v.StartedAt = new(int64)
			return d.ReadInt64(schemas.JobSummary_startedAt, v.StartedAt)
		case schemas.JobSummary_status:
			var ev string
			if err := d.ReadString(schemas.JobSummary_status, &ev); err != nil {
				return err
			}
			v.Status = JobStatus(ev)
			return nil
		case schemas.JobSummary_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.JobSummary_statusReason, v.StatusReason)
		case schemas.JobSummary_stoppedAt:
			v.StoppedAt = new(int64)
			return d.ReadInt64(schemas.JobSummary_stoppedAt, v.StoppedAt)
		}
		return nil
	})
}

// An object that represents a job timeout configuration.
type JobTimeout struct {

	// The job timeout time (in seconds) that's measured from the job attempt's
	// startedAt timestamp. After this time passes, Batch terminates your jobs if they
	// aren't finished. The minimum value for the timeout is 60 seconds.
	//
	// For array jobs, the timeout applies to the child jobs, not to the parent array
	// job.
	//
	// For multi-node parallel (MNP) jobs, the timeout applies to the whole job, not
	// to the individual nodes.
	AttemptDurationSeconds *int32

	noSmithyDocumentSerde
}

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

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

// A key-value pair object.
type KeyValuePair struct {

	// The name of the key-value pair. For environment variables, this is the name of
	// the environment variable.
	Name *string

	// The value of the key-value pair. For environment variables, this is the value
	// of the environment variable.
	Value *string

	noSmithyDocumentSerde
}

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

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

// A filter name and value pair that's used to return a more specific list of
// results from a ListJobs or ListJobsByConsumableResource API operation.
type KeyValuesPair struct {

	// The name of the filter. Filter names are case sensitive.
	Name *string

	// The filter values.
	Values []string

	noSmithyDocumentSerde
}

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

func (v *KeyValuesPair) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != nil {
		s.WriteString(schemas.KeyValuesPair_name, *v.Name)
	}
	if v.Values != nil {
		serializeStringList(s, schemas.KeyValuesPair_values, v.Values)
	}
}
func (v *KeyValuesPair) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.KeyValuesPair, func(s *smithy.Schema) error {
		switch s {
		case schemas.KeyValuesPair_name:
			v.Name = new(string)
			return d.ReadString(schemas.KeyValuesPair_name, v.Name)
		case schemas.KeyValuesPair_values:
			return deserializeStringList(d, schemas.KeyValuesPair_values, &v.Values)
		}
		return nil
	})
}

// Information about the latest attempt of a service job. A Service job can
// transition from SCHEDULED back to RUNNABLE state when they encounter capacity
// constraints.
type LatestServiceJobAttempt struct {

	// The service resource identifier associated with the service job attempt.
	ServiceResourceId *ServiceResourceId

	noSmithyDocumentSerde
}

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

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

// An object that represents a launch template that's associated with a compute
// resource. You must specify either the launch template ID or launch template name
// in the request, but not both.
//
// If security groups are specified using both the securityGroupIds parameter of
// CreateComputeEnvironment and the launch template, the values in the
// securityGroupIds parameter of CreateComputeEnvironment will be used.
//
// This object isn't applicable to jobs that are running on Fargate resources.
type LaunchTemplateSpecification struct {

	// The ID of the launch template.
	LaunchTemplateId *string

	// The name of the launch template.
	LaunchTemplateName *string

	// A launch template to use in place of the default launch template. You must
	// specify either the launch template ID or launch template name in the request,
	// but not both.
	//
	// You can specify up to ten (10) launch template overrides that are associated to
	// unique instance types or families for each compute environment.
	//
	// To unset all override templates for a compute environment, you can pass an
	// empty array to the [UpdateComputeEnvironment.overrides]parameter, or not include the overrides parameter when
	// submitting the UpdateComputeEnvironment API operation.
	//
	// [UpdateComputeEnvironment.overrides]: https://docs.aws.amazon.com/batch/latest/APIReference/API_UpdateComputeEnvironment.html
	Overrides []LaunchTemplateSpecificationOverride

	// The EKS node initialization process to use. You only need to specify this value
	// if you are using a custom AMI. The default value is EKS_BOOTSTRAP_SH . If
	// imageType is a custom AMI based on EKS_AL2023 or EKS_AL2023_NVIDIA then you must
	// choose EKS_NODEADM .
	UserdataType UserdataType

	// The version number of the launch template, $Default , or $Latest .
	//
	// If the value is $Default , the default version of the launch template is used.
	// If the value is $Latest , the latest version of the launch template is used.
	//
	// If the AMI ID that's used in a compute environment is from the launch template,
	// the AMI isn't changed when the compute environment is updated. It's only changed
	// if the updateToLatestImageVersion parameter for the compute environment is set
	// to true . During an infrastructure update, if either $Default or $Latest is
	// specified, Batch re-evaluates the launch template version, and it might use a
	// different version of the launch template. This is the case even if the launch
	// template isn't specified in the update. When updating a compute environment,
	// changing the launch template requires an infrastructure update of the compute
	// environment. For more information, see [Updating compute environments]in the Batch User Guide.
	//
	// Default: $Default
	//
	// Latest: $Latest
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	Version *string

	noSmithyDocumentSerde
}

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

func (v *LaunchTemplateSpecification) SerializeMembers(s smithy.ShapeSerializer) {
	if v.LaunchTemplateId != nil {
		s.WriteString(schemas.LaunchTemplateSpecification_launchTemplateId, *v.LaunchTemplateId)
	}
	if v.LaunchTemplateName != nil {
		s.WriteString(schemas.LaunchTemplateSpecification_launchTemplateName, *v.LaunchTemplateName)
	}
	if v.Overrides != nil {
		serializeLaunchTemplateSpecificationOverrideList(s, schemas.LaunchTemplateSpecification_overrides, v.Overrides)
	}
	if v.UserdataType != "" {
		s.WriteString(schemas.LaunchTemplateSpecification_userdataType, string(v.UserdataType))
	}
	if v.Version != nil {
		s.WriteString(schemas.LaunchTemplateSpecification_version, *v.Version)
	}
}
func (v *LaunchTemplateSpecification) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LaunchTemplateSpecification, func(s *smithy.Schema) error {
		switch s {
		case schemas.LaunchTemplateSpecification_launchTemplateId:
			v.LaunchTemplateId = new(string)
			return d.ReadString(schemas.LaunchTemplateSpecification_launchTemplateId, v.LaunchTemplateId)
		case schemas.LaunchTemplateSpecification_launchTemplateName:
			v.LaunchTemplateName = new(string)
			return d.ReadString(schemas.LaunchTemplateSpecification_launchTemplateName, v.LaunchTemplateName)
		case schemas.LaunchTemplateSpecification_overrides:
			return deserializeLaunchTemplateSpecificationOverrideList(d, schemas.LaunchTemplateSpecification_overrides, &v.Overrides)
		case schemas.LaunchTemplateSpecification_userdataType:
			var ev string
			if err := d.ReadString(schemas.LaunchTemplateSpecification_userdataType, &ev); err != nil {
				return err
			}
			v.UserdataType = UserdataType(ev)
			return nil
		case schemas.LaunchTemplateSpecification_version:
			v.Version = new(string)
			return d.ReadString(schemas.LaunchTemplateSpecification_version, v.Version)
		}
		return nil
	})
}

// An object that represents a launch template to use in place of the default
// launch template. You must specify either the launch template ID or launch
// template name in the request, but not both.
//
// If security groups are specified using both the securityGroupIds parameter of
// CreateComputeEnvironment and the launch template, the values in the
// securityGroupIds parameter of CreateComputeEnvironment will be used.
//
// You can define up to ten (10) overrides for each compute environment.
//
// This object isn't applicable to jobs that are running on Fargate resources.
//
// To unset all override templates for a compute environment, you can pass an
// empty array to the [UpdateComputeEnvironment.overrides]parameter, or not include the overrides parameter when
// submitting the UpdateComputeEnvironment API operation.
//
// [UpdateComputeEnvironment.overrides]: https://docs.aws.amazon.com/batch/latest/APIReference/API_UpdateComputeEnvironment.html
type LaunchTemplateSpecificationOverride struct {

	// The ID of the launch template.
	//
	// Note: If you specify the launchTemplateId you can't specify the
	// launchTemplateName as well.
	LaunchTemplateId *string

	// The name of the launch template.
	//
	// Note: If you specify the launchTemplateName you can't specify the
	// launchTemplateId as well.
	LaunchTemplateName *string

	// The instance type or family that this override launch template should be
	// applied to.
	//
	// This parameter is required when defining a launch template override.
	//
	// Information included in this parameter must meet the following requirements:
	//
	//   - Must be a valid Amazon EC2 instance type or family.
	//
	//   - The following Batch InstanceTypes are not allowed: optimal , default_x86_64
	//   , and default_arm64 .
	//
	//   - targetInstanceTypes can target only instance types and families that are
	//   included within the [ComputeResource.instanceTypes]ComputeResource.instanceTypes set. targetInstanceTypes
	//   doesn't need to include all of the instances from the instanceType set, but at
	//   least a subset. For example, if ComputeResource.instanceTypes includes [m5,
	//   g5] , targetInstanceTypes can include [m5.2xlarge] and [m5.large] but not
	//   [c5.large] .
	//
	//   - targetInstanceTypes included within the same launch template override or
	//   across launch template overrides can't overlap for the same compute environment.
	//   For example, you can't define one launch template override to target an instance
	//   family and another define an instance type within this same family.
	//
	// [ComputeResource.instanceTypes]: https://docs.aws.amazon.com/batch/latest/APIReference/API_ComputeResource.html#Batch-Type-ComputeResource-instanceTypes
	TargetInstanceTypes []string

	// The EKS node initialization process to use. You only need to specify this value
	// if you are using a custom AMI. The default value is EKS_BOOTSTRAP_SH . If
	// imageType is a custom AMI based on EKS_AL2023 or EKS_AL2023_NVIDIA then you must
	// choose EKS_NODEADM .
	UserdataType UserdataType

	// The version number of the launch template, $Default , or $Latest .
	//
	// If the value is $Default , the default version of the launch template is used.
	// If the value is $Latest , the latest version of the launch template is used.
	//
	// If the AMI ID that's used in a compute environment is from the launch template,
	// the AMI isn't changed when the compute environment is updated. It's only changed
	// if the updateToLatestImageVersion parameter for the compute environment is set
	// to true . During an infrastructure update, if either $Default or $Latest is
	// specified, Batch re-evaluates the launch template version, and it might use a
	// different version of the launch template. This is the case even if the launch
	// template isn't specified in the update. When updating a compute environment,
	// changing the launch template requires an infrastructure update of the compute
	// environment. For more information, see [Updating compute environments]in the Batch User Guide.
	//
	// Default: $Default
	//
	// Latest: $Latest
	//
	// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
	Version *string

	noSmithyDocumentSerde
}

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

func (v *LaunchTemplateSpecificationOverride) SerializeMembers(s smithy.ShapeSerializer) {
	if v.LaunchTemplateId != nil {
		s.WriteString(schemas.LaunchTemplateSpecificationOverride_launchTemplateId, *v.LaunchTemplateId)
	}
	if v.LaunchTemplateName != nil {
		s.WriteString(schemas.LaunchTemplateSpecificationOverride_launchTemplateName, *v.LaunchTemplateName)
	}
	if v.TargetInstanceTypes != nil {
		serializeStringList(s, schemas.LaunchTemplateSpecificationOverride_targetInstanceTypes, v.TargetInstanceTypes)
	}
	if v.UserdataType != "" {
		s.WriteString(schemas.LaunchTemplateSpecificationOverride_userdataType, string(v.UserdataType))
	}
	if v.Version != nil {
		s.WriteString(schemas.LaunchTemplateSpecificationOverride_version, *v.Version)
	}
}
func (v *LaunchTemplateSpecificationOverride) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LaunchTemplateSpecificationOverride, func(s *smithy.Schema) error {
		switch s {
		case schemas.LaunchTemplateSpecificationOverride_launchTemplateId:
			v.LaunchTemplateId = new(string)
			return d.ReadString(schemas.LaunchTemplateSpecificationOverride_launchTemplateId, v.LaunchTemplateId)
		case schemas.LaunchTemplateSpecificationOverride_launchTemplateName:
			v.LaunchTemplateName = new(string)
			return d.ReadString(schemas.LaunchTemplateSpecificationOverride_launchTemplateName, v.LaunchTemplateName)
		case schemas.LaunchTemplateSpecificationOverride_targetInstanceTypes:
			return deserializeStringList(d, schemas.LaunchTemplateSpecificationOverride_targetInstanceTypes, &v.TargetInstanceTypes)
		case schemas.LaunchTemplateSpecificationOverride_userdataType:
			var ev string
			if err := d.ReadString(schemas.LaunchTemplateSpecificationOverride_userdataType, &ev); err != nil {
				return err
			}
			v.UserdataType = UserdataType(ev)
			return nil
		case schemas.LaunchTemplateSpecificationOverride_version:
			v.Version = new(string)
			return d.ReadString(schemas.LaunchTemplateSpecificationOverride_version, v.Version)
		}
		return nil
	})
}

// Linux-specific modifications that are applied to the container, such as details
// for device mappings.
type LinuxParameters struct {

	// Any of the host devices to expose to the container. This parameter maps to
	// Devices in the [Create a container] section of the [Docker Remote API] and the --device option to [docker run].
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't provide it for these jobs.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Devices []Device

	// If true, run an init process inside the container that forwards signals and
	// reaps processes. This parameter maps to the --init option to [docker run]. This parameter
	// requires version 1.25 of the Docker Remote API or greater on your container
	// instance. To check the Docker Remote API version on your container instance, log
	// in to your container instance and run the following command: sudo docker
	// version | grep "Server API version"
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	InitProcessEnabled *bool

	// The total amount of swap memory (in MiB) a container can use. This parameter is
	// translated to the --memory-swap option to [docker run] where the value is the sum of the
	// container memory plus the maxSwap value. For more information, see [--memory-swap details]--memory-swap
	// in the Docker documentation.
	//
	// If a maxSwap value of 0 is specified, the container doesn't use swap. Accepted
	// values are 0 or any positive integer. If the maxSwap parameter is omitted, the
	// container doesn't use the swap configuration for the container instance on which
	// it runs. A maxSwap value must be set for the swappiness parameter to be used.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't provide it for these jobs.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [--memory-swap details]: https://docs.docker.com/config/containers/resource_constraints/#--memory-swap-details
	MaxSwap *int32

	// The value for the size (in MiB) of the /dev/shm volume. This parameter maps to
	// the --shm-size option to [docker run].
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't provide it for these jobs.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	SharedMemorySize *int32

	// You can use this parameter to tune a container's memory swappiness behavior. A
	// swappiness value of 0 causes swapping to not occur unless absolutely necessary.
	// A swappiness value of 100 causes pages to be swapped aggressively. Valid values
	// are whole numbers between 0 and 100 . If the swappiness parameter isn't
	// specified, a default value of 60 is used. If a value isn't specified for maxSwap
	// , then this parameter is ignored. If maxSwap is set to 0, the container doesn't
	// use swap. This parameter maps to the --memory-swappiness option to [docker run].
	//
	// Consider the following when you use a per-container swap configuration.
	//
	//   - Swap space must be enabled and allocated on the container instance for the
	//   containers to use.
	//
	// By default, the Amazon ECS optimized AMIs don't have swap enabled. You must
	//   enable swap on the instance to use this feature. For more information, see [Instance store swap volumes]in
	//   the Amazon EC2 User Guide for Linux Instances or [How do I allocate memory to work as swap space in an Amazon EC2 instance by using a swap file?]
	//
	//   - The swap space parameters are only supported for job definitions using EC2
	//   resources.
	//
	//   - If the maxSwap and swappiness parameters are omitted from a job definition,
	//   each container has a default swappiness value of 60. Moreover, the total swap
	//   usage is limited to two times the memory reservation of the container.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't provide it for these jobs.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Instance store swap volumes]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-store-swap-volumes.html
	// [How do I allocate memory to work as swap space in an Amazon EC2 instance by using a swap file?]: http://aws.amazon.com/premiumsupport/knowledge-center/ec2-memory-swap-file/
	Swappiness *int32

	// The container path, mount options, and size (in MiB) of the tmpfs mount. This
	// parameter maps to the --tmpfs option to [docker run].
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	// Don't provide this parameter for this resource type.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	Tmpfs []Tmpfs

	noSmithyDocumentSerde
}

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

func (v *LinuxParameters) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Devices != nil {
		serializeDevicesList(s, schemas.LinuxParameters_devices, v.Devices)
	}
	if v.InitProcessEnabled != nil {
		s.WriteBool(schemas.LinuxParameters_initProcessEnabled, *v.InitProcessEnabled)
	}
	if v.MaxSwap != nil {
		s.WriteInt32(schemas.LinuxParameters_maxSwap, *v.MaxSwap)
	}
	if v.SharedMemorySize != nil {
		s.WriteInt32(schemas.LinuxParameters_sharedMemorySize, *v.SharedMemorySize)
	}
	if v.Swappiness != nil {
		s.WriteInt32(schemas.LinuxParameters_swappiness, *v.Swappiness)
	}
	if v.Tmpfs != nil {
		serializeTmpfsList(s, schemas.LinuxParameters_tmpfs, v.Tmpfs)
	}
}
func (v *LinuxParameters) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LinuxParameters, func(s *smithy.Schema) error {
		switch s {
		case schemas.LinuxParameters_devices:
			return deserializeDevicesList(d, schemas.LinuxParameters_devices, &v.Devices)
		case schemas.LinuxParameters_initProcessEnabled:
			v.InitProcessEnabled = new(bool)
			return d.ReadBool(schemas.LinuxParameters_initProcessEnabled, v.InitProcessEnabled)
		case schemas.LinuxParameters_maxSwap:
			v.MaxSwap = new(int32)
			return d.ReadInt32(schemas.LinuxParameters_maxSwap, v.MaxSwap)
		case schemas.LinuxParameters_sharedMemorySize:
			v.SharedMemorySize = new(int32)
			return d.ReadInt32(schemas.LinuxParameters_sharedMemorySize, v.SharedMemorySize)
		case schemas.LinuxParameters_swappiness:
			v.Swappiness = new(int32)
			return d.ReadInt32(schemas.LinuxParameters_swappiness, v.Swappiness)
		case schemas.LinuxParameters_tmpfs:
			return deserializeTmpfsList(d, schemas.LinuxParameters_tmpfs, &v.Tmpfs)
		}
		return nil
	})
}

// Current information about a consumable resource required by a job.
type ListJobsByConsumableResourceSummary struct {

	// Contains a list of consumable resources required by the job.
	//
	// This member is required.
	ConsumableResourceProperties *ConsumableResourceProperties

	// The Unix timestamp (in milliseconds) for when the consumable resource was
	// created.
	//
	// This member is required.
	CreatedAt *int64

	// The Amazon Resource Name (ARN) of the job.
	//
	// This member is required.
	JobArn *string

	// The name of the job.
	//
	// This member is required.
	JobName *string

	// The Amazon Resource Name (ARN) of the job queue.
	//
	// This member is required.
	JobQueueArn *string

	// The status of the job. Can be one of:
	//
	//   - SUBMITTED
	//
	//   - PENDING
	//
	//   - RUNNABLE
	//
	//   - STARTING
	//
	//   - RUNNING
	//
	//   - SUCCEEDED
	//
	//   - FAILED
	//
	// This member is required.
	JobStatus *string

	// The total amount of the consumable resource that is available.
	//
	// This member is required.
	Quantity *int64

	// The Amazon Resource Name (ARN) of the job definition.
	JobDefinitionArn *string

	// The fair-share scheduling identifier for the job.
	ShareIdentifier *string

	// The Unix timestamp for when the job was started. More specifically, it's when
	// the job transitioned from the STARTING state to the RUNNING state.
	StartedAt *int64

	// A short, human-readable string to provide more details for the current status
	// of the job.
	StatusReason *string

	noSmithyDocumentSerde
}

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

func (v *ListJobsByConsumableResourceSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ConsumableResourceProperties != nil {
		s.WriteStruct(schemas.ListJobsByConsumableResourceSummary_consumableResourceProperties)
		v.ConsumableResourceProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.CreatedAt != nil {
		s.WriteInt64(schemas.ListJobsByConsumableResourceSummary_createdAt, *v.CreatedAt)
	}
	if v.JobArn != nil {
		s.WriteString(schemas.ListJobsByConsumableResourceSummary_jobArn, *v.JobArn)
	}
	if v.JobDefinitionArn != nil {
		s.WriteString(schemas.ListJobsByConsumableResourceSummary_jobDefinitionArn, *v.JobDefinitionArn)
	}
	if v.JobName != nil {
		s.WriteString(schemas.ListJobsByConsumableResourceSummary_jobName, *v.JobName)
	}
	if v.JobQueueArn != nil {
		s.WriteString(schemas.ListJobsByConsumableResourceSummary_jobQueueArn, *v.JobQueueArn)
	}
	if v.JobStatus != nil {
		s.WriteString(schemas.ListJobsByConsumableResourceSummary_jobStatus, *v.JobStatus)
	}
	if v.Quantity != nil {
		s.WriteInt64(schemas.ListJobsByConsumableResourceSummary_quantity, *v.Quantity)
	}
	if v.ShareIdentifier != nil {
		s.WriteString(schemas.ListJobsByConsumableResourceSummary_shareIdentifier, *v.ShareIdentifier)
	}
	if v.StartedAt != nil {
		s.WriteInt64(schemas.ListJobsByConsumableResourceSummary_startedAt, *v.StartedAt)
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.ListJobsByConsumableResourceSummary_statusReason, *v.StatusReason)
	}
}
func (v *ListJobsByConsumableResourceSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ListJobsByConsumableResourceSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.ListJobsByConsumableResourceSummary_consumableResourceProperties:
			v.ConsumableResourceProperties = &ConsumableResourceProperties{}
			return v.ConsumableResourceProperties.Deserialize(d)
		case schemas.ListJobsByConsumableResourceSummary_createdAt:
			v.CreatedAt = new(int64)
			return d.ReadInt64(schemas.ListJobsByConsumableResourceSummary_createdAt, v.CreatedAt)
		case schemas.ListJobsByConsumableResourceSummary_jobArn:
			v.JobArn = new(string)
			return d.ReadString(schemas.ListJobsByConsumableResourceSummary_jobArn, v.JobArn)
		case schemas.ListJobsByConsumableResourceSummary_jobDefinitionArn:
			v.JobDefinitionArn = new(string)
			return d.ReadString(schemas.ListJobsByConsumableResourceSummary_jobDefinitionArn, v.JobDefinitionArn)
		case schemas.ListJobsByConsumableResourceSummary_jobName:
			v.JobName = new(string)
			return d.ReadString(schemas.ListJobsByConsumableResourceSummary_jobName, v.JobName)
		case schemas.ListJobsByConsumableResourceSummary_jobQueueArn:
			v.JobQueueArn = new(string)
			return d.ReadString(schemas.ListJobsByConsumableResourceSummary_jobQueueArn, v.JobQueueArn)
		case schemas.ListJobsByConsumableResourceSummary_jobStatus:
			v.JobStatus = new(string)
			return d.ReadString(schemas.ListJobsByConsumableResourceSummary_jobStatus, v.JobStatus)
		case schemas.ListJobsByConsumableResourceSummary_quantity:
			v.Quantity = new(int64)
			return d.ReadInt64(schemas.ListJobsByConsumableResourceSummary_quantity, v.Quantity)
		case schemas.ListJobsByConsumableResourceSummary_shareIdentifier:
			v.ShareIdentifier = new(string)
			return d.ReadString(schemas.ListJobsByConsumableResourceSummary_shareIdentifier, v.ShareIdentifier)
		case schemas.ListJobsByConsumableResourceSummary_startedAt:
			v.StartedAt = new(int64)
			return d.ReadInt64(schemas.ListJobsByConsumableResourceSummary_startedAt, v.StartedAt)
		case schemas.ListJobsByConsumableResourceSummary_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.ListJobsByConsumableResourceSummary_statusReason, v.StatusReason)
		}
		return nil
	})
}

// Log configuration options to send to a custom log driver for the container.
type LogConfiguration struct {

	// The log driver to use for the container. The valid values that are listed for
	// this parameter are log drivers that the Amazon ECS container agent can
	// communicate with by default.
	//
	// The supported log drivers are awsfirelens , awslogs , fluentd , gelf , json-file
	// , journald , logentries , syslog , and splunk .
	//
	// Jobs that are running on Fargate resources are restricted to the awslogs and
	// splunk log drivers.
	//
	// awsfirelens Specifies the firelens logging driver. For more information on
	// configuring Firelens, see [Send Amazon ECS logs to an Amazon Web Services service or Amazon Web Services Partner]in the Amazon Elastic Container Service Developer
	// Guide.
	//
	// awslogs Specifies the Amazon CloudWatch Logs logging driver. For more
	// information, see [Using the awslogs log driver]in the Batch User Guide and [Amazon CloudWatch Logs logging driver] in the Docker documentation.
	//
	// fluentd Specifies the Fluentd logging driver. For more information including
	// usage and options, see [Fluentd logging driver]in the Docker documentation.
	//
	// gelf Specifies the Graylog Extended Format (GELF) logging driver. For more
	// information including usage and options, see [Graylog Extended Format logging driver]in the Docker documentation.
	//
	// journald Specifies the journald logging driver. For more information including
	// usage and options, see [Journald logging driver]in the Docker documentation.
	//
	// json-file Specifies the JSON file logging driver. For more information
	// including usage and options, see [JSON File logging driver]in the Docker documentation.
	//
	// splunk Specifies the Splunk logging driver. For more information including
	// usage and options, see [Splunk logging driver]in the Docker documentation.
	//
	// syslog Specifies the syslog logging driver. For more information including
	// usage and options, see [Syslog logging driver]in the Docker documentation.
	//
	// If you have a custom driver that's not listed earlier that you want to work
	// with the Amazon ECS container agent, you can fork the Amazon ECS container agent
	// project that's [available on GitHub]and customize it to work with that driver. We encourage you to
	// submit pull requests for changes that you want to have included. However, Amazon
	// Web Services doesn't currently support running modified copies of this software.
	//
	// This parameter requires version 1.18 of the Docker Remote API or greater on
	// your container instance. To check the Docker Remote API version on your
	// container instance, log in to your container instance and run the following
	// command: sudo docker version | grep "Server API version"
	//
	// [Journald logging driver]: https://docs.docker.com/config/containers/logging/journald/
	// [Syslog logging driver]: https://docs.docker.com/config/containers/logging/syslog/
	// [JSON File logging driver]: https://docs.docker.com/config/containers/logging/json-file/
	// [Splunk logging driver]: https://docs.docker.com/config/containers/logging/splunk/
	// [Send Amazon ECS logs to an Amazon Web Services service or Amazon Web Services Partner]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html
	// [Amazon CloudWatch Logs logging driver]: https://docs.docker.com/config/containers/logging/awslogs/
	// [available on GitHub]: https://github.com/aws/amazon-ecs-agent
	// [Using the awslogs log driver]: https://docs.aws.amazon.com/batch/latest/userguide/using_awslogs.html
	// [Fluentd logging driver]: https://docs.docker.com/config/containers/logging/fluentd/
	// [Graylog Extended Format logging driver]: https://docs.docker.com/config/containers/logging/gelf/
	//
	// This member is required.
	LogDriver LogDriver

	// The configuration options to send to the log driver. This parameter requires
	// version 1.19 of the Docker Remote API or greater on your container instance. To
	// check the Docker Remote API version on your container instance, log in to your
	// container instance and run the following command: sudo docker version | grep
	// "Server API version"
	Options map[string]string

	// The secrets to pass to the log configuration. For more information, see [Specifying sensitive data] in the
	// Batch User Guide.
	//
	// [Specifying sensitive data]: https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data.html
	SecretOptions []Secret

	noSmithyDocumentSerde
}

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

func (v *LogConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.LogDriver != "" {
		s.WriteString(schemas.LogConfiguration_logDriver, string(v.LogDriver))
	}
	if v.Options != nil {
		serializeLogConfigurationOptionsMap(s, schemas.LogConfiguration_options, v.Options)
	}
	if v.SecretOptions != nil {
		serializeSecretList(s, schemas.LogConfiguration_secretOptions, v.SecretOptions)
	}
}
func (v *LogConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.LogConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.LogConfiguration_logDriver:
			var ev string
			if err := d.ReadString(schemas.LogConfiguration_logDriver, &ev); err != nil {
				return err
			}
			v.LogDriver = LogDriver(ev)
			return nil
		case schemas.LogConfiguration_options:
			return deserializeLogConfigurationOptionsMap(d, schemas.LogConfiguration_options, &v.Options)
		case schemas.LogConfiguration_secretOptions:
			return deserializeSecretList(d, schemas.LogConfiguration_secretOptions, &v.SecretOptions)
		}
		return nil
	})
}

// The local storage configuration for Amazon ECS Managed Instances.
type ManagedInstancesLocalStorageConfiguration struct {

	// Specifies whether instance store volumes (local NVMe SSDs) are available to
	// containers. When enabled, containers can use the instance store for
	// high-performance temporary storage.
	UseLocalStorage *bool

	noSmithyDocumentSerde
}

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

func (v *ManagedInstancesLocalStorageConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.UseLocalStorage != nil {
		s.WriteBool(schemas.ManagedInstancesLocalStorageConfiguration_useLocalStorage, *v.UseLocalStorage)
	}
}
func (v *ManagedInstancesLocalStorageConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ManagedInstancesLocalStorageConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.ManagedInstancesLocalStorageConfiguration_useLocalStorage:
			v.UseLocalStorage = new(bool)
			return d.ReadBool(schemas.ManagedInstancesLocalStorageConfiguration_useLocalStorage, v.UseLocalStorage)
		}
		return nil
	})
}

// The network configuration for Amazon ECS Managed Instances. Specifies the VPC
// subnets and security groups where instances are launched.
type ManagedInstancesNetworkConfiguration struct {

	// The VPC security groups to associate with the managed instances.
	//
	// This member is required.
	SecurityGroups []string

	// The VPC subnets where managed instances are launched. If your subnets don't
	// provide public IP addresses, they must have a NAT gateway for outbound internet
	// access.
	//
	// This member is required.
	Subnets []string

	noSmithyDocumentSerde
}

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

func (v *ManagedInstancesNetworkConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.SecurityGroups != nil {
		serializeStringList(s, schemas.ManagedInstancesNetworkConfiguration_securityGroups, v.SecurityGroups)
	}
	if v.Subnets != nil {
		serializeStringList(s, schemas.ManagedInstancesNetworkConfiguration_subnets, v.Subnets)
	}
}
func (v *ManagedInstancesNetworkConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ManagedInstancesNetworkConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.ManagedInstancesNetworkConfiguration_securityGroups:
			return deserializeStringList(d, schemas.ManagedInstancesNetworkConfiguration_securityGroups, &v.SecurityGroups)
		case schemas.ManagedInstancesNetworkConfiguration_subnets:
			return deserializeStringList(d, schemas.ManagedInstancesNetworkConfiguration_subnets, &v.Subnets)
		}
		return nil
	})
}

// The configuration for an Amazon ECS Managed Instances capacity provider. This
// object is required when creating a compute environment with
// computeResources.type set to ECS_MANAGED_INSTANCES .
type ManagedInstancesProvider struct {

	// The Amazon Resource Name (ARN) of the IAM role that Amazon ECS assumes to
	// manage Amazon EC2 instances on your behalf. This role must have a trust policy
	// for ecs.amazonaws.com . You must have the iam:PassRole permission for this role
	// with the condition iam:PassedToService: ecs.amazonaws.com .
	//
	// This member is required.
	InfrastructureRoleArn *string

	// The instance launch configuration for the Amazon ECS Managed Instances capacity
	// provider. Contains networking, instance profile, instance requirements, capacity
	// type, storage, and monitoring configuration.
	//
	// This member is required.
	InstanceLaunchTemplate *InstanceLaunchTemplate

	// The infrastructure optimization configuration for the capacity provider.
	// Specifies the idle-instance scale-in behavior.
	InfrastructureOptimization *InfrastructureOptimization

	// Specifies whether tags on the capacity provider are propagated to the Amazon
	// EC2 instances it launches. Valid values:
	//
	//   - CAPACITY_PROVIDER — Propagates tags to instances.
	//
	//   - NONE (default) — Does not propagate tags to instances.
	PropagateTags *string

	noSmithyDocumentSerde
}

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

func (v *ManagedInstancesProvider) SerializeMembers(s smithy.ShapeSerializer) {
	if v.InfrastructureOptimization != nil {
		s.WriteStruct(schemas.ManagedInstancesProvider_infrastructureOptimization)
		v.InfrastructureOptimization.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.InfrastructureRoleArn != nil {
		s.WriteString(schemas.ManagedInstancesProvider_infrastructureRoleArn, *v.InfrastructureRoleArn)
	}
	if v.InstanceLaunchTemplate != nil {
		s.WriteStruct(schemas.ManagedInstancesProvider_instanceLaunchTemplate)
		v.InstanceLaunchTemplate.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.PropagateTags != nil {
		s.WriteString(schemas.ManagedInstancesProvider_propagateTags, *v.PropagateTags)
	}
}
func (v *ManagedInstancesProvider) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ManagedInstancesProvider, func(s *smithy.Schema) error {
		switch s {
		case schemas.ManagedInstancesProvider_infrastructureOptimization:
			v.InfrastructureOptimization = &InfrastructureOptimization{}
			return v.InfrastructureOptimization.Deserialize(d)
		case schemas.ManagedInstancesProvider_infrastructureRoleArn:
			v.InfrastructureRoleArn = new(string)
			return d.ReadString(schemas.ManagedInstancesProvider_infrastructureRoleArn, v.InfrastructureRoleArn)
		case schemas.ManagedInstancesProvider_instanceLaunchTemplate:
			v.InstanceLaunchTemplate = &InstanceLaunchTemplate{}
			return v.InstanceLaunchTemplate.Deserialize(d)
		case schemas.ManagedInstancesProvider_propagateTags:
			v.PropagateTags = new(string)
			return d.ReadString(schemas.ManagedInstancesProvider_propagateTags, v.PropagateTags)
		}
		return nil
	})
}

// The storage configuration for Amazon ECS Managed Instances.
type ManagedInstancesStorageConfiguration struct {

	// The size of the root EBS volume in GiB for the managed instances.
	StorageSizeGiB *int32

	noSmithyDocumentSerde
}

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

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

// Details for a Docker volume mount point that's used in a job's container
// properties. This parameter maps to Volumes in the [Create a container] section of the Docker Remote
// API and the --volume option to docker run.
//
// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
type MountPoint struct {

	// The path on the container where the host volume is mounted.
	ContainerPath *string

	// If this value is true , the container has read-only access to the volume.
	// Otherwise, the container can write to the volume. The default value is false .
	ReadOnly *bool

	// The name of the volume to mount.
	SourceVolume *string

	noSmithyDocumentSerde
}

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

func (v *MountPoint) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerPath != nil {
		s.WriteString(schemas.MountPoint_containerPath, *v.ContainerPath)
	}
	if v.ReadOnly != nil {
		s.WriteBool(schemas.MountPoint_readOnly, *v.ReadOnly)
	}
	if v.SourceVolume != nil {
		s.WriteString(schemas.MountPoint_sourceVolume, *v.SourceVolume)
	}
}
func (v *MountPoint) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.MountPoint, func(s *smithy.Schema) error {
		switch s {
		case schemas.MountPoint_containerPath:
			v.ContainerPath = new(string)
			return d.ReadString(schemas.MountPoint_containerPath, v.ContainerPath)
		case schemas.MountPoint_readOnly:
			v.ReadOnly = new(bool)
			return d.ReadBool(schemas.MountPoint_readOnly, v.ReadOnly)
		case schemas.MountPoint_sourceVolume:
			v.SourceVolume = new(string)
			return d.ReadString(schemas.MountPoint_sourceVolume, v.SourceVolume)
		}
		return nil
	})
}

// The network configuration for jobs that are running on Fargate resources. Jobs
// that are running on Amazon EC2 resources must not specify this parameter.
type NetworkConfiguration struct {

	// Indicates whether the job has a public IP address. For a job that's running on
	// Fargate resources in a private subnet to send outbound traffic to the internet
	// (for example, to pull container images), the private subnet requires a NAT
	// gateway be attached to route requests to the internet. For more information, see
	// [Amazon ECS task networking]in the Amazon Elastic Container Service Developer Guide. The default value is "
	// DISABLED ".
	//
	// [Amazon ECS task networking]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html
	AssignPublicIp AssignPublicIp

	noSmithyDocumentSerde
}

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

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

// An object that represents the elastic network interface for a multi-node
// parallel job node.
type NetworkInterface struct {

	// The attachment ID for the network interface.
	AttachmentId *string

	// The private IPv6 address for the network interface.
	Ipv6Address *string

	// The private IPv4 address for the network interface.
	PrivateIpv4Address *string

	noSmithyDocumentSerde
}

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

func (v *NetworkInterface) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AttachmentId != nil {
		s.WriteString(schemas.NetworkInterface_attachmentId, *v.AttachmentId)
	}
	if v.Ipv6Address != nil {
		s.WriteString(schemas.NetworkInterface_ipv6Address, *v.Ipv6Address)
	}
	if v.PrivateIpv4Address != nil {
		s.WriteString(schemas.NetworkInterface_privateIpv4Address, *v.PrivateIpv4Address)
	}
}
func (v *NetworkInterface) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.NetworkInterface, func(s *smithy.Schema) error {
		switch s {
		case schemas.NetworkInterface_attachmentId:
			v.AttachmentId = new(string)
			return d.ReadString(schemas.NetworkInterface_attachmentId, v.AttachmentId)
		case schemas.NetworkInterface_ipv6Address:
			v.Ipv6Address = new(string)
			return d.ReadString(schemas.NetworkInterface_ipv6Address, v.Ipv6Address)
		case schemas.NetworkInterface_privateIpv4Address:
			v.PrivateIpv4Address = new(string)
			return d.ReadString(schemas.NetworkInterface_privateIpv4Address, v.PrivateIpv4Address)
		}
		return nil
	})
}

// An object that represents the details of a multi-node parallel job node.
type NodeDetails struct {

	// Specifies whether the current node is the main node for a multi-node parallel
	// job.
	IsMainNode *bool

	// The node index for the node. Node index numbering starts at zero. This index is
	// also available on the node with the AWS_BATCH_JOB_NODE_INDEX environment
	// variable.
	NodeIndex *int32

	noSmithyDocumentSerde
}

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

func (v *NodeDetails) SerializeMembers(s smithy.ShapeSerializer) {
	if v.IsMainNode != nil {
		s.WriteBool(schemas.NodeDetails_isMainNode, *v.IsMainNode)
	}
	if v.NodeIndex != nil {
		s.WriteInt32(schemas.NodeDetails_nodeIndex, *v.NodeIndex)
	}
}
func (v *NodeDetails) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.NodeDetails, func(s *smithy.Schema) error {
		switch s {
		case schemas.NodeDetails_isMainNode:
			v.IsMainNode = new(bool)
			return d.ReadBool(schemas.NodeDetails_isMainNode, v.IsMainNode)
		case schemas.NodeDetails_nodeIndex:
			v.NodeIndex = new(int32)
			return d.ReadInt32(schemas.NodeDetails_nodeIndex, v.NodeIndex)
		}
		return nil
	})
}

// An object that represents any node overrides to a job definition that's used in
// a [SubmitJob]API operation.
//
// This parameter isn't applicable to jobs that are running on Fargate resources.
// Don't provide it for these jobs. Rather, use containerOverrides instead.
//
// [SubmitJob]: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html
type NodeOverrides struct {

	// The node property overrides for the job.
	NodePropertyOverrides []NodePropertyOverride

	// The number of nodes to use with a multi-node parallel job. This value overrides
	// the number of nodes that are specified in the job definition. To use this
	// override, you must meet the following conditions:
	//
	//   - There must be at least one node range in your job definition that has an
	//   open upper boundary, such as : or n: .
	//
	//   - The lower boundary of the node range that's specified in the job definition
	//   must be fewer than the number of nodes specified in the override.
	//
	//   - The main node index that's specified in the job definition must be fewer
	//   than the number of nodes specified in the override.
	NumNodes *int32

	noSmithyDocumentSerde
}

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

func (v *NodeOverrides) SerializeMembers(s smithy.ShapeSerializer) {
	if v.NodePropertyOverrides != nil {
		serializeNodePropertyOverrides(s, schemas.NodeOverrides_nodePropertyOverrides, v.NodePropertyOverrides)
	}
	if v.NumNodes != nil {
		s.WriteInt32(schemas.NodeOverrides_numNodes, *v.NumNodes)
	}
}
func (v *NodeOverrides) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.NodeOverrides, func(s *smithy.Schema) error {
		switch s {
		case schemas.NodeOverrides_nodePropertyOverrides:
			return deserializeNodePropertyOverrides(d, schemas.NodeOverrides_nodePropertyOverrides, &v.NodePropertyOverrides)
		case schemas.NodeOverrides_numNodes:
			v.NumNodes = new(int32)
			return d.ReadInt32(schemas.NodeOverrides_numNodes, v.NumNodes)
		}
		return nil
	})
}

// An object that represents the node properties of a multi-node parallel job.
//
// Node properties can't be specified for Amazon EKS based job definitions.
type NodeProperties struct {

	// Specifies the node index for the main node of a multi-node parallel job. This
	// node index value must be fewer than the number of nodes.
	//
	// This member is required.
	MainNode *int32

	// A list of node ranges and their properties that are associated with a
	// multi-node parallel job.
	//
	// This member is required.
	NodeRangeProperties []NodeRangeProperty

	// The number of nodes that are associated with a multi-node parallel job.
	//
	// This member is required.
	NumNodes *int32

	noSmithyDocumentSerde
}

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

func (v *NodeProperties) SerializeMembers(s smithy.ShapeSerializer) {
	if v.MainNode != nil {
		s.WriteInt32(schemas.NodeProperties_mainNode, *v.MainNode)
	}
	if v.NodeRangeProperties != nil {
		serializeNodeRangeProperties(s, schemas.NodeProperties_nodeRangeProperties, v.NodeRangeProperties)
	}
	if v.NumNodes != nil {
		s.WriteInt32(schemas.NodeProperties_numNodes, *v.NumNodes)
	}
}
func (v *NodeProperties) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.NodeProperties, func(s *smithy.Schema) error {
		switch s {
		case schemas.NodeProperties_mainNode:
			v.MainNode = new(int32)
			return d.ReadInt32(schemas.NodeProperties_mainNode, v.MainNode)
		case schemas.NodeProperties_nodeRangeProperties:
			return deserializeNodeRangeProperties(d, schemas.NodeProperties_nodeRangeProperties, &v.NodeRangeProperties)
		case schemas.NodeProperties_numNodes:
			v.NumNodes = new(int32)
			return d.ReadInt32(schemas.NodeProperties_numNodes, v.NumNodes)
		}
		return nil
	})
}

// An object that represents the properties of a node that's associated with a
// multi-node parallel job.
type NodePropertiesSummary struct {

	// Specifies whether the current node is the main node for a multi-node parallel
	// job.
	IsMainNode *bool

	// The node index for the node. Node index numbering begins at zero. This index is
	// also available on the node with the AWS_BATCH_JOB_NODE_INDEX environment
	// variable.
	NodeIndex *int32

	// The number of nodes that are associated with a multi-node parallel job.
	NumNodes *int32

	noSmithyDocumentSerde
}

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

func (v *NodePropertiesSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.IsMainNode != nil {
		s.WriteBool(schemas.NodePropertiesSummary_isMainNode, *v.IsMainNode)
	}
	if v.NodeIndex != nil {
		s.WriteInt32(schemas.NodePropertiesSummary_nodeIndex, *v.NodeIndex)
	}
	if v.NumNodes != nil {
		s.WriteInt32(schemas.NodePropertiesSummary_numNodes, *v.NumNodes)
	}
}
func (v *NodePropertiesSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.NodePropertiesSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.NodePropertiesSummary_isMainNode:
			v.IsMainNode = new(bool)
			return d.ReadBool(schemas.NodePropertiesSummary_isMainNode, v.IsMainNode)
		case schemas.NodePropertiesSummary_nodeIndex:
			v.NodeIndex = new(int32)
			return d.ReadInt32(schemas.NodePropertiesSummary_nodeIndex, v.NodeIndex)
		case schemas.NodePropertiesSummary_numNodes:
			v.NumNodes = new(int32)
			return d.ReadInt32(schemas.NodePropertiesSummary_numNodes, v.NumNodes)
		}
		return nil
	})
}

// The object that represents any node overrides to a job definition that's used
// in a [SubmitJob]API operation.
//
// [SubmitJob]: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html
type NodePropertyOverride struct {

	// The range of nodes, using node index values, that's used to override. A range
	// of 0:3 indicates nodes with index values of 0 through 3 . If the starting range
	// value is omitted ( :n ), then 0 is used to start the range. If the ending range
	// value is omitted ( n: ), then the highest possible node index is used to end the
	// range.
	//
	// This member is required.
	TargetNodes *string

	// An object that contains overrides for the consumable resources of a job.
	ConsumableResourcePropertiesOverride *ConsumableResourceProperties

	// The overrides that are sent to a node range.
	ContainerOverrides *ContainerOverrides

	// An object that contains the properties that you want to replace for the
	// existing Amazon ECS resources of a job.
	EcsPropertiesOverride *EcsPropertiesOverride

	// An object that contains the properties that you want to replace for the
	// existing Amazon EKS resources of a job.
	EksPropertiesOverride *EksPropertiesOverride

	// An object that contains the instance types that you want to replace for the
	// existing resources of a job.
	InstanceTypes []string

	noSmithyDocumentSerde
}

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

func (v *NodePropertyOverride) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ConsumableResourcePropertiesOverride != nil {
		s.WriteStruct(schemas.NodePropertyOverride_consumableResourcePropertiesOverride)
		v.ConsumableResourcePropertiesOverride.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ContainerOverrides != nil {
		s.WriteStruct(schemas.NodePropertyOverride_containerOverrides)
		v.ContainerOverrides.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EcsPropertiesOverride != nil {
		s.WriteStruct(schemas.NodePropertyOverride_ecsPropertiesOverride)
		v.EcsPropertiesOverride.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EksPropertiesOverride != nil {
		s.WriteStruct(schemas.NodePropertyOverride_eksPropertiesOverride)
		v.EksPropertiesOverride.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.InstanceTypes != nil {
		serializeStringList(s, schemas.NodePropertyOverride_instanceTypes, v.InstanceTypes)
	}
	if v.TargetNodes != nil {
		s.WriteString(schemas.NodePropertyOverride_targetNodes, *v.TargetNodes)
	}
}
func (v *NodePropertyOverride) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.NodePropertyOverride, func(s *smithy.Schema) error {
		switch s {
		case schemas.NodePropertyOverride_consumableResourcePropertiesOverride:
			v.ConsumableResourcePropertiesOverride = &ConsumableResourceProperties{}
			return v.ConsumableResourcePropertiesOverride.Deserialize(d)
		case schemas.NodePropertyOverride_containerOverrides:
			v.ContainerOverrides = &ContainerOverrides{}
			return v.ContainerOverrides.Deserialize(d)
		case schemas.NodePropertyOverride_ecsPropertiesOverride:
			v.EcsPropertiesOverride = &EcsPropertiesOverride{}
			return v.EcsPropertiesOverride.Deserialize(d)
		case schemas.NodePropertyOverride_eksPropertiesOverride:
			v.EksPropertiesOverride = &EksPropertiesOverride{}
			return v.EksPropertiesOverride.Deserialize(d)
		case schemas.NodePropertyOverride_instanceTypes:
			return deserializeStringList(d, schemas.NodePropertyOverride_instanceTypes, &v.InstanceTypes)
		case schemas.NodePropertyOverride_targetNodes:
			v.TargetNodes = new(string)
			return d.ReadString(schemas.NodePropertyOverride_targetNodes, v.TargetNodes)
		}
		return nil
	})
}

// This is an object that represents the properties of the node range for a
// multi-node parallel job.
type NodeRangeProperty struct {

	// The range of nodes, using node index values. A range of 0:3 indicates nodes
	// with index values of 0 through 3 . If the starting range value is omitted ( :n
	// ), then 0 is used to start the range. If the ending range value is omitted ( n:
	// ), then the highest possible node index is used to end the range. Your
	// accumulative node ranges must account for all nodes ( 0:n ). You can nest node
	// ranges (for example, 0:10 and 4:5 ). In this case, the 4:5 range properties
	// override the 0:10 properties.
	//
	// This member is required.
	TargetNodes *string

	// Contains a list of consumable resources required by a job.
	ConsumableResourceProperties *ConsumableResourceProperties

	// The container details for the node range.
	Container *ContainerProperties

	// This is an object that represents the properties of the node range for a
	// multi-node parallel job.
	EcsProperties *EcsProperties

	// This is an object that represents the properties of the node range for a
	// multi-node parallel job.
	EksProperties *EksProperties

	// The instance types of the underlying host infrastructure of a multi-node
	// parallel job.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources.
	//
	// In addition, this list object is currently limited to one element.
	InstanceTypes []string

	noSmithyDocumentSerde
}

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

func (v *NodeRangeProperty) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ConsumableResourceProperties != nil {
		s.WriteStruct(schemas.NodeRangeProperty_consumableResourceProperties)
		v.ConsumableResourceProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Container != nil {
		s.WriteStruct(schemas.NodeRangeProperty_container)
		v.Container.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EcsProperties != nil {
		s.WriteStruct(schemas.NodeRangeProperty_ecsProperties)
		v.EcsProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.EksProperties != nil {
		s.WriteStruct(schemas.NodeRangeProperty_eksProperties)
		v.EksProperties.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.InstanceTypes != nil {
		serializeStringList(s, schemas.NodeRangeProperty_instanceTypes, v.InstanceTypes)
	}
	if v.TargetNodes != nil {
		s.WriteString(schemas.NodeRangeProperty_targetNodes, *v.TargetNodes)
	}
}
func (v *NodeRangeProperty) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.NodeRangeProperty, func(s *smithy.Schema) error {
		switch s {
		case schemas.NodeRangeProperty_consumableResourceProperties:
			v.ConsumableResourceProperties = &ConsumableResourceProperties{}
			return v.ConsumableResourceProperties.Deserialize(d)
		case schemas.NodeRangeProperty_container:
			v.Container = &ContainerProperties{}
			return v.Container.Deserialize(d)
		case schemas.NodeRangeProperty_ecsProperties:
			v.EcsProperties = &EcsProperties{}
			return v.EcsProperties.Deserialize(d)
		case schemas.NodeRangeProperty_eksProperties:
			v.EksProperties = &EksProperties{}
			return v.EksProperties.Deserialize(d)
		case schemas.NodeRangeProperty_instanceTypes:
			return deserializeStringList(d, schemas.NodeRangeProperty_instanceTypes, &v.InstanceTypes)
		case schemas.NodeRangeProperty_targetNodes:
			v.TargetNodes = new(string)
			return d.ReadString(schemas.NodeRangeProperty_targetNodes, v.TargetNodes)
		}
		return nil
	})
}

// The configured capacity usage for a job queue snapshot, including the unit of
// measure and quantity of resources being used.
type QueueSnapshotCapacityUsage struct {

	// The unit of measure for the capacity usage. For compute jobs, this is VCPU for
	// Amazon EC2 and cpu for Amazon EKS. For service jobs, this is the instance type.
	CapacityUnit *string

	// The quantity of capacity being used in the queue snapshot, measured in the
	// units specified by capacityUnit .
	Quantity *float64

	noSmithyDocumentSerde
}

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

func (v *QueueSnapshotCapacityUsage) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUnit != nil {
		s.WriteString(schemas.QueueSnapshotCapacityUsage_capacityUnit, *v.CapacityUnit)
	}
	if v.Quantity != nil {
		s.WriteFloat64(schemas.QueueSnapshotCapacityUsage_quantity, *v.Quantity)
	}
}
func (v *QueueSnapshotCapacityUsage) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.QueueSnapshotCapacityUsage, func(s *smithy.Schema) error {
		switch s {
		case schemas.QueueSnapshotCapacityUsage_capacityUnit:
			v.CapacityUnit = new(string)
			return d.ReadString(schemas.QueueSnapshotCapacityUsage_capacityUnit, v.CapacityUnit)
		case schemas.QueueSnapshotCapacityUsage_quantity:
			v.Quantity = new(float64)
			return d.ReadFloat64(schemas.QueueSnapshotCapacityUsage_quantity, v.Quantity)
		}
		return nil
	})
}

// The job queue utilization at a specific point in time, including total capacity
// usage, and quota share or fairshare utilization breakdown depending on the job
// queue scheduling policy.
type QueueSnapshotUtilizationDetail struct {

	// The utilization information for a fairshare scheduling job queues, including
	// active share count and top capacity utilization by share.
	FairshareUtilization *FairshareUtilizationDetail

	// The Unix timestamp (in milliseconds) for when the queue utilization information
	// was last updated.
	LastUpdatedAt *int64

	// The utilization information for a job queue with a quota share scheduling
	// policy.
	QuotaShareUtilization *QuotaShareUtilizationDetail

	// The total capacity usage for the entire job queue.
	TotalCapacityUsage []QueueSnapshotCapacityUsage

	noSmithyDocumentSerde
}

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

func (v *QueueSnapshotUtilizationDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.FairshareUtilization != nil {
		s.WriteStruct(schemas.QueueSnapshotUtilizationDetail_fairshareUtilization)
		v.FairshareUtilization.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LastUpdatedAt != nil {
		s.WriteInt64(schemas.QueueSnapshotUtilizationDetail_lastUpdatedAt, *v.LastUpdatedAt)
	}
	if v.QuotaShareUtilization != nil {
		s.WriteStruct(schemas.QueueSnapshotUtilizationDetail_quotaShareUtilization)
		v.QuotaShareUtilization.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.TotalCapacityUsage != nil {
		serializeQueueSnapshotCapacityUsageList(s, schemas.QueueSnapshotUtilizationDetail_totalCapacityUsage, v.TotalCapacityUsage)
	}
}
func (v *QueueSnapshotUtilizationDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.QueueSnapshotUtilizationDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.QueueSnapshotUtilizationDetail_fairshareUtilization:
			v.FairshareUtilization = &FairshareUtilizationDetail{}
			return v.FairshareUtilization.Deserialize(d)
		case schemas.QueueSnapshotUtilizationDetail_lastUpdatedAt:
			v.LastUpdatedAt = new(int64)
			return d.ReadInt64(schemas.QueueSnapshotUtilizationDetail_lastUpdatedAt, v.LastUpdatedAt)
		case schemas.QueueSnapshotUtilizationDetail_quotaShareUtilization:
			v.QuotaShareUtilization = &QuotaShareUtilizationDetail{}
			return v.QuotaShareUtilization.Deserialize(d)
		case schemas.QueueSnapshotUtilizationDetail_totalCapacityUsage:
			return deserializeQueueSnapshotCapacityUsageList(d, schemas.QueueSnapshotUtilizationDetail_totalCapacityUsage, &v.TotalCapacityUsage)
		}
		return nil
	})
}

// Defines the capacity limit for a quota share, or the type and maximum quantity
// of a particular resource that can be allocated to jobs in the quota share
// without borrowing.
type QuotaShareCapacityLimit struct {

	// The unit of compute capacity for the capacityLimit. For example, ml.m5.large .
	//
	// This member is required.
	CapacityUnit *string

	// The maximum capacity available for the quota share. This value represents the
	// maximum quantity of a resource that can be allocated to jobs in the quota share
	// without borrowing.
	//
	// This member is required.
	MaxCapacity *int32

	noSmithyDocumentSerde
}

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

func (v *QuotaShareCapacityLimit) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUnit != nil {
		s.WriteString(schemas.QuotaShareCapacityLimit_capacityUnit, *v.CapacityUnit)
	}
	if v.MaxCapacity != nil {
		s.WriteInt32(schemas.QuotaShareCapacityLimit_maxCapacity, *v.MaxCapacity)
	}
}
func (v *QuotaShareCapacityLimit) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.QuotaShareCapacityLimit, func(s *smithy.Schema) error {
		switch s {
		case schemas.QuotaShareCapacityLimit_capacityUnit:
			v.CapacityUnit = new(string)
			return d.ReadString(schemas.QuotaShareCapacityLimit_capacityUnit, v.CapacityUnit)
		case schemas.QuotaShareCapacityLimit_maxCapacity:
			v.MaxCapacity = new(int32)
			return d.ReadInt32(schemas.QuotaShareCapacityLimit_maxCapacity, v.MaxCapacity)
		}
		return nil
	})
}

// The capacity usage for a quota share, including units of compute capacity and
// quantity of resources being used.
type QuotaShareCapacityUsage struct {

	// The unit of compute capacity for the capacity usage.
	CapacityUnit *string

	// The quantity of capacity being used.
	Quantity *float64

	noSmithyDocumentSerde
}

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

func (v *QuotaShareCapacityUsage) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUnit != nil {
		s.WriteString(schemas.QuotaShareCapacityUsage_capacityUnit, *v.CapacityUnit)
	}
	if v.Quantity != nil {
		s.WriteFloat64(schemas.QuotaShareCapacityUsage_quantity, *v.Quantity)
	}
}
func (v *QuotaShareCapacityUsage) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.QuotaShareCapacityUsage, func(s *smithy.Schema) error {
		switch s {
		case schemas.QuotaShareCapacityUsage_capacityUnit:
			v.CapacityUnit = new(string)
			return d.ReadString(schemas.QuotaShareCapacityUsage_capacityUnit, v.CapacityUnit)
		case schemas.QuotaShareCapacityUsage_quantity:
			v.Quantity = new(float64)
			return d.ReadFloat64(schemas.QuotaShareCapacityUsage_quantity, v.Quantity)
		}
		return nil
	})
}

// The capacity utilization for a specific quota share, including the quota share
// name and its current usage.
type QuotaShareCapacityUtilization struct {

	// The capacity usage information for this quota share, including the units of
	// compute capacity and quantity being used.
	CapacityUsage []QuotaShareCapacityUsage

	// The name of the quota share.
	QuotaShareName *string

	noSmithyDocumentSerde
}

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

func (v *QuotaShareCapacityUtilization) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUsage != nil {
		serializeQuotaShareCapacityUsageList(s, schemas.QuotaShareCapacityUtilization_capacityUsage, v.CapacityUsage)
	}
	if v.QuotaShareName != nil {
		s.WriteString(schemas.QuotaShareCapacityUtilization_quotaShareName, *v.QuotaShareName)
	}
}
func (v *QuotaShareCapacityUtilization) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.QuotaShareCapacityUtilization, func(s *smithy.Schema) error {
		switch s {
		case schemas.QuotaShareCapacityUtilization_capacityUsage:
			return deserializeQuotaShareCapacityUsageList(d, schemas.QuotaShareCapacityUtilization_capacityUsage, &v.CapacityUsage)
		case schemas.QuotaShareCapacityUtilization_quotaShareName:
			v.QuotaShareName = new(string)
			return d.ReadString(schemas.QuotaShareCapacityUtilization_quotaShareName, v.QuotaShareName)
		}
		return nil
	})
}

// Detailed information about a quota share, including its configuration, state,
// and capacity limits.
type QuotaShareDetail struct {

	// A list that specifies the quantity and type of compute capacity allocated to
	// the quota share.
	CapacityLimits []QuotaShareCapacityLimit

	// The Amazon Resource Name (ARN) of the job queue associated with the quota share.
	JobQueueArn *string

	// Specifies the preemption behavior for jobs in a quota share.
	PreemptionConfiguration *QuotaSharePreemptionConfiguration

	// The Amazon Resource Name (ARN) of the quota share.
	QuotaShareArn *string

	// The name of the quota share.
	QuotaShareName *string

	// Specifies whether a quota share reserves, lends, or both lends and borrows idle
	// compute capacity.
	ResourceSharingConfiguration *QuotaShareResourceSharingConfiguration

	// The state of the quota share.
	State QuotaShareState

	// The current status of the quota share.
	Status QuotaShareStatus

	noSmithyDocumentSerde
}

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

func (v *QuotaShareDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityLimits != nil {
		serializeQuotaShareCapacityLimits(s, schemas.QuotaShareDetail_capacityLimits, v.CapacityLimits)
	}
	if v.JobQueueArn != nil {
		s.WriteString(schemas.QuotaShareDetail_jobQueueArn, *v.JobQueueArn)
	}
	if v.PreemptionConfiguration != nil {
		s.WriteStruct(schemas.QuotaShareDetail_preemptionConfiguration)
		v.PreemptionConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.QuotaShareArn != nil {
		s.WriteString(schemas.QuotaShareDetail_quotaShareArn, *v.QuotaShareArn)
	}
	if v.QuotaShareName != nil {
		s.WriteString(schemas.QuotaShareDetail_quotaShareName, *v.QuotaShareName)
	}
	if v.ResourceSharingConfiguration != nil {
		s.WriteStruct(schemas.QuotaShareDetail_resourceSharingConfiguration)
		v.ResourceSharingConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.State != "" {
		s.WriteString(schemas.QuotaShareDetail_state, string(v.State))
	}
	if v.Status != "" {
		s.WriteString(schemas.QuotaShareDetail_status, string(v.Status))
	}
}
func (v *QuotaShareDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.QuotaShareDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.QuotaShareDetail_capacityLimits:
			return deserializeQuotaShareCapacityLimits(d, schemas.QuotaShareDetail_capacityLimits, &v.CapacityLimits)
		case schemas.QuotaShareDetail_jobQueueArn:
			v.JobQueueArn = new(string)
			return d.ReadString(schemas.QuotaShareDetail_jobQueueArn, v.JobQueueArn)
		case schemas.QuotaShareDetail_preemptionConfiguration:
			v.PreemptionConfiguration = &QuotaSharePreemptionConfiguration{}
			return v.PreemptionConfiguration.Deserialize(d)
		case schemas.QuotaShareDetail_quotaShareArn:
			v.QuotaShareArn = new(string)
			return d.ReadString(schemas.QuotaShareDetail_quotaShareArn, v.QuotaShareArn)
		case schemas.QuotaShareDetail_quotaShareName:
			v.QuotaShareName = new(string)
			return d.ReadString(schemas.QuotaShareDetail_quotaShareName, v.QuotaShareName)
		case schemas.QuotaShareDetail_resourceSharingConfiguration:
			v.ResourceSharingConfiguration = &QuotaShareResourceSharingConfiguration{}
			return v.ResourceSharingConfiguration.Deserialize(d)
		case schemas.QuotaShareDetail_state:
			var ev string
			if err := d.ReadString(schemas.QuotaShareDetail_state, &ev); err != nil {
				return err
			}
			v.State = QuotaShareState(ev)
			return nil
		case schemas.QuotaShareDetail_status:
			var ev string
			if err := d.ReadString(schemas.QuotaShareDetail_status, &ev); err != nil {
				return err
			}
			v.Status = QuotaShareStatus(ev)
			return nil
		}
		return nil
	})
}

// The quota share scheduling policy details for a job queue.
type QuotaSharePolicy struct {

	// The strategy that determines how idle resources are assigned to quota shares
	// that are borrowing capacity. Currently, only FIFO is supported.
	//
	// This member is required.
	IdleResourceAssignmentStrategy QuotaShareIdleResourceAssignmentStrategy

	noSmithyDocumentSerde
}

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

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

// Specifies the preemption behavior for jobs in a quota share.
type QuotaSharePreemptionConfiguration struct {

	// Specifies whether jobs within a quota share can be preempted by another, higher
	// priority job in the same quota share.
	//
	// This member is required.
	InSharePreemption QuotaShareInSharePreemptionState

	noSmithyDocumentSerde
}

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

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

// Specifies whether a quota share reserves, lends, or both lends and borrows idle
// compute capacity.
type QuotaShareResourceSharingConfiguration struct {

	// The resource sharing strategy for the quota share. The RESERVE strategy allows
	// a quota share to reserve idle capacity for itself. LEND configures the share to
	// lend its idle capacity to another share in need of capacity. The LEND_AND_BORROW
	// strategy configures the share to borrow idle capacity from an underutilized
	// share, as well as lend to another share.
	//
	// This member is required.
	Strategy QuotaShareResourceSharingStrategy

	// The maximum percentage of additional capacity that the quota share can borrow
	// from other shares. borrowLimit can only be applied to quota shares with a
	// strategy of LEND_AND_BORROW . This value is expressed as a percentage of the
	// quota share's configured [CapacityLimits].
	//
	// The borrowLimit is applied uniformly across all capacity units. For example, if
	// the borrowLimit is 200, the quota share can borrow up to 200% of its configured
	// maxCapacity for each capacity unit. The default borrowLimit is -1, which
	// indicates unlimited borrowing.
	//
	// [CapacityLimits]: https://docs.aws.amazon.com/batch/latest/APIReference/API_QuotaShareCapacityLimit.html
	BorrowLimit *int32

	noSmithyDocumentSerde
}

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

func (v *QuotaShareResourceSharingConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.BorrowLimit != nil {
		s.WriteInt32(schemas.QuotaShareResourceSharingConfiguration_borrowLimit, *v.BorrowLimit)
	}
	if v.Strategy != "" {
		s.WriteString(schemas.QuotaShareResourceSharingConfiguration_strategy, string(v.Strategy))
	}
}
func (v *QuotaShareResourceSharingConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.QuotaShareResourceSharingConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.QuotaShareResourceSharingConfiguration_borrowLimit:
			v.BorrowLimit = new(int32)
			return d.ReadInt32(schemas.QuotaShareResourceSharingConfiguration_borrowLimit, v.BorrowLimit)
		case schemas.QuotaShareResourceSharingConfiguration_strategy:
			var ev string
			if err := d.ReadString(schemas.QuotaShareResourceSharingConfiguration_strategy, &ev); err != nil {
				return err
			}
			v.Strategy = QuotaShareResourceSharingStrategy(ev)
			return nil
		}
		return nil
	})
}

// An object that represents the capacity utilization details of all quota shares
// associated with a single job queue.
type QuotaShareUtilizationDetail struct {

	// A list of the top capacity utilizations across quota shares associated with a
	// job queue.
	TopCapacityUtilization []QuotaShareCapacityUtilization

	noSmithyDocumentSerde
}

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

func (v *QuotaShareUtilizationDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.TopCapacityUtilization != nil {
		serializeQuotaShareCapacityUtilizationList(s, schemas.QuotaShareUtilizationDetail_topCapacityUtilization, v.TopCapacityUtilization)
	}
}
func (v *QuotaShareUtilizationDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.QuotaShareUtilizationDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.QuotaShareUtilizationDetail_topCapacityUtilization:
			return deserializeQuotaShareCapacityUtilizationList(d, schemas.QuotaShareUtilizationDetail_topCapacityUtilization, &v.TopCapacityUtilization)
		}
		return nil
	})
}

// The repository credentials for private registry authentication.
type RepositoryCredentials struct {

	// The Amazon Resource Name (ARN) of the secret containing the private repository
	// credentials.
	//
	// This member is required.
	CredentialsParameter *string

	noSmithyDocumentSerde
}

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

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

// The type and amount of a resource to assign to a container. The supported
// resources include GPU , MEMORY , and VCPU .
type ResourceRequirement struct {

	// The type of resource to assign to a container. The supported resources include
	// GPU , MEMORY , and VCPU .
	//
	// This member is required.
	Type ResourceType

	// The quantity of the specified resource to reserve for the container. The values
	// vary based on the type specified.
	//
	// type="GPU" The number of physical GPUs to reserve for the container. Make sure
	// that the number of GPUs reserved for all containers in a job doesn't exceed the
	// number of available GPUs on the compute resource that the job is launched on.
	//
	// GPUs aren't available for jobs that are running on Fargate resources.
	//
	// type="MEMORY" The memory hard limit (in MiB) present to the container. This
	// parameter is supported for jobs that are running on Amazon EC2 resources. If
	// your container attempts to exceed the memory specified, the container is
	// terminated. This parameter maps to Memory in the [Create a container] section of the [Docker Remote API] and the
	// --memory option to [docker run]. You must specify at least 4 MiB of memory for a job. This
	// is required but can be specified in several places for multi-node parallel (MNP)
	// jobs. It must be specified for each node at least once. This parameter maps to
	// Memory in the [Create a container] section of the [Docker Remote API] and the --memory option to [docker run].
	//
	// If you're trying to maximize your resource utilization by providing your jobs
	// as much memory as possible for a particular instance type, see [Memory management]in the Batch
	// User Guide.
	//
	// For jobs that are running on Fargate resources, then value is the hard limit
	// (in MiB), and must match one of the supported values and the VCPU values must
	// be one of the values supported for that memory value.
	//
	// value = 512 VCPU = 0.25
	//
	// value = 1024 VCPU = 0.25 or 0.5
	//
	// value = 2048 VCPU = 0.25, 0.5, or 1
	//
	// value = 3072 VCPU = 0.5, or 1
	//
	// value = 4096 VCPU = 0.5, 1, or 2
	//
	// value = 5120, 6144, or 7168 VCPU = 1 or 2
	//
	// value = 8192 VCPU = 1, 2, or 4
	//
	// value = 9216, 10240, 11264, 12288, 13312, 14336, or 15360 VCPU = 2 or 4
	//
	// value = 16384 VCPU = 2, 4, or 8
	//
	// value = 17408, 18432, 19456, 21504, 22528, 23552, 25600, 26624, 27648, 29696,
	// or 30720 VCPU = 4
	//
	// value = 20480, 24576, or 28672 VCPU = 4 or 8
	//
	// value = 36864, 45056, or 53248 VCPU = 8
	//
	// value = 61440 VCPU = 8 or 32
	//
	// value = 32768, 40960, 49152, or 57344 VCPU = 8 or 16
	//
	// value = 65536, 73728, 81920, 90112, 98304, 106496, or 114688 VCPU = 16
	//
	// value = 122880 VCPU = 16 or 32
	//
	// value = 249856 VCPU = 32
	//
	// type="VCPU" The number of vCPUs reserved for the container. This parameter maps
	// to CpuShares in the [Create a container] section of the [Docker Remote API] and the --cpu-shares option to [docker run]. Each vCPU
	// is equivalent to 1,024 CPU shares. For Amazon EC2 resources, you must specify at
	// least one vCPU. This is required but can be specified in several places; it must
	// be specified for each node at least once.
	//
	// The default for the Fargate On-Demand vCPU resource count quota is 6 vCPUs. For
	// more information about Fargate quotas, see [Fargate quotas]in the Amazon Web Services General
	// Reference.
	//
	// For jobs that are running on Fargate resources, then value must match one of
	// the supported values and the MEMORY values must be one of the values supported
	// for that VCPU value. The supported values are 0.25, 0.5, 1, 2, 4, 8, 16, and 32.
	//
	// value = 0.25 MEMORY = 512, 1024, or 2048
	//
	// value = 0.5 MEMORY = 1024, 2048, 3072, or 4096
	//
	// value = 1 MEMORY = 2048, 3072, 4096, 5120, 6144, 7168, or 8192
	//
	// value = 2 MEMORY = 4096, 5120, 6144, 7168, 8192, 9216, 10240, 11264, 12288,
	// 13312, 14336, 15360, or 16384
	//
	// value = 4 MEMORY = 8192, 9216, 10240, 11264, 12288, 13312, 14336, 15360, 16384,
	// 17408, 18432, 19456, 20480, 21504, 22528, 23552, 24576, 25600, 26624, 27648,
	// 28672, 29696, or 30720
	//
	// value = 8 MEMORY = 16384, 20480, 24576, 28672, 32768, 36864, 40960, 45056,
	// 49152, 53248, 57344, or 61440
	//
	// value = 16 MEMORY = 32768, 40960, 49152, 57344, 65536, 73728, 81920, 90112,
	// 98304, 106496, 114688, or 122880
	//
	// value = 32 MEMORY = 61440, 122880, or 249856
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Memory management]: https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	// [Fargate quotas]: https://docs.aws.amazon.com/general/latest/gr/ecs-service.html#service-quotas-fargate
	//
	// This member is required.
	Value *string

	noSmithyDocumentSerde
}

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

func (v *ResourceRequirement) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Type != "" {
		s.WriteString(schemas.ResourceRequirement_type, string(v.Type))
	}
	if v.Value != nil {
		s.WriteString(schemas.ResourceRequirement_value, *v.Value)
	}
}
func (v *ResourceRequirement) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ResourceRequirement, func(s *smithy.Schema) error {
		switch s {
		case schemas.ResourceRequirement_type:
			var ev string
			if err := d.ReadString(schemas.ResourceRequirement_type, &ev); err != nil {
				return err
			}
			v.Type = ResourceType(ev)
			return nil
		case schemas.ResourceRequirement_value:
			v.Value = new(string)
			return d.ReadString(schemas.ResourceRequirement_value, v.Value)
		}
		return nil
	})
}

// The retry strategy that's associated with a job. For more information, see [Automated job retries] in
// the Batch User Guide.
//
// [Automated job retries]: https://docs.aws.amazon.com/batch/latest/userguide/job_retries.html
type RetryStrategy struct {

	// The number of times to move a job to the RUNNABLE status. You can specify
	// between 1 and 10 attempts. If the value of attempts is greater than one, the
	// job is retried on failure the same number of attempts as the value.
	Attempts *int32

	// Array of up to 5 objects that specify the conditions where jobs are retried or
	// failed. If this parameter is specified, then the attempts parameter must also
	// be specified. If none of the listed conditions match, then the job is retried.
	EvaluateOnExit []EvaluateOnExit

	noSmithyDocumentSerde
}

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

func (v *RetryStrategy) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Attempts != nil {
		s.WriteInt32(schemas.RetryStrategy_attempts, *v.Attempts)
	}
	if v.EvaluateOnExit != nil {
		serializeEvaluateOnExitList(s, schemas.RetryStrategy_evaluateOnExit, v.EvaluateOnExit)
	}
}
func (v *RetryStrategy) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RetryStrategy, func(s *smithy.Schema) error {
		switch s {
		case schemas.RetryStrategy_attempts:
			v.Attempts = new(int32)
			return d.ReadInt32(schemas.RetryStrategy_attempts, v.Attempts)
		case schemas.RetryStrategy_evaluateOnExit:
			return deserializeEvaluateOnExitList(d, schemas.RetryStrategy_evaluateOnExit, &v.EvaluateOnExit)
		}
		return nil
	})
}

//	An object that represents the compute environment architecture for Batch jobs
//
// on Fargate.
type RuntimePlatform struct {

	// The vCPU architecture. The default value is X86_64 . Valid values are X86_64
	// and ARM64 .
	//
	// This parameter must be set to X86_64 for Windows containers.
	//
	// Fargate Spot is not supported on Windows-based containers on Fargate. A job
	// queue will be blocked if a Windows job is submitted to a job queue with only
	// Fargate Spot compute environments. However, you can attach both FARGATE and
	// FARGATE_SPOT compute environments to the same job queue.
	CpuArchitecture *string

	// The operating system for the compute environment. Valid values are: LINUX
	// (default), WINDOWS_SERVER_2019_CORE , WINDOWS_SERVER_2019_FULL ,
	// WINDOWS_SERVER_2022_CORE , and WINDOWS_SERVER_2022_FULL .
	//
	// The following parameters can’t be set for Windows containers: linuxParameters ,
	// privileged , user , ulimits , readonlyRootFilesystem , and
	// efsVolumeConfiguration .
	//
	// The Batch Scheduler checks the compute environments that are attached to the
	// job queue before registering a task definition with Fargate. In this scenario,
	// the job queue is where the job is submitted. If the job requires a Windows
	// container and the first compute environment is LINUX , the compute environment
	// is skipped and the next compute environment is checked until a Windows-based
	// compute environment is found.
	//
	// Fargate Spot is not supported on Windows-based containers on Fargate. A job
	// queue will be blocked if a Windows job is submitted to a job queue with only
	// Fargate Spot compute environments. However, you can attach both FARGATE and
	// FARGATE_SPOT compute environments to the same job queue.
	OperatingSystemFamily *string

	noSmithyDocumentSerde
}

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

func (v *RuntimePlatform) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CpuArchitecture != nil {
		s.WriteString(schemas.RuntimePlatform_cpuArchitecture, *v.CpuArchitecture)
	}
	if v.OperatingSystemFamily != nil {
		s.WriteString(schemas.RuntimePlatform_operatingSystemFamily, *v.OperatingSystemFamily)
	}
}
func (v *RuntimePlatform) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.RuntimePlatform, func(s *smithy.Schema) error {
		switch s {
		case schemas.RuntimePlatform_cpuArchitecture:
			v.CpuArchitecture = new(string)
			return d.ReadString(schemas.RuntimePlatform_cpuArchitecture, v.CpuArchitecture)
		case schemas.RuntimePlatform_operatingSystemFamily:
			v.OperatingSystemFamily = new(string)
			return d.ReadString(schemas.RuntimePlatform_operatingSystemFamily, v.OperatingSystemFamily)
		}
		return nil
	})
}

// This is used when you're using an S3Files file system for job storage.
type S3FilesVolumeConfiguration struct {

	// The Amazon Resource Name (ARN) of the S3Files file system to use.
	//
	// This member is required.
	FileSystemArn *string

	// The Amazon Resource Name (ARN) of the S3Files access point to use.
	AccessPointArn *string

	// The directory within the S3Files file system to mount as the root directory.
	RootDirectory *string

	// The port to use when sending encrypted data between the Amazon ECS host and the
	// S3Files file system server.
	TransitEncryptionPort *int32

	noSmithyDocumentSerde
}

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

func (v *S3FilesVolumeConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.AccessPointArn != nil {
		s.WriteString(schemas.S3FilesVolumeConfiguration_accessPointArn, *v.AccessPointArn)
	}
	if v.FileSystemArn != nil {
		s.WriteString(schemas.S3FilesVolumeConfiguration_fileSystemArn, *v.FileSystemArn)
	}
	if v.RootDirectory != nil {
		s.WriteString(schemas.S3FilesVolumeConfiguration_rootDirectory, *v.RootDirectory)
	}
	if v.TransitEncryptionPort != nil {
		s.WriteInt32(schemas.S3FilesVolumeConfiguration_transitEncryptionPort, *v.TransitEncryptionPort)
	}
}
func (v *S3FilesVolumeConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.S3FilesVolumeConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.S3FilesVolumeConfiguration_accessPointArn:
			v.AccessPointArn = new(string)
			return d.ReadString(schemas.S3FilesVolumeConfiguration_accessPointArn, v.AccessPointArn)
		case schemas.S3FilesVolumeConfiguration_fileSystemArn:
			v.FileSystemArn = new(string)
			return d.ReadString(schemas.S3FilesVolumeConfiguration_fileSystemArn, v.FileSystemArn)
		case schemas.S3FilesVolumeConfiguration_rootDirectory:
			v.RootDirectory = new(string)
			return d.ReadString(schemas.S3FilesVolumeConfiguration_rootDirectory, v.RootDirectory)
		case schemas.S3FilesVolumeConfiguration_transitEncryptionPort:
			v.TransitEncryptionPort = new(int32)
			return d.ReadInt32(schemas.S3FilesVolumeConfiguration_transitEncryptionPort, v.TransitEncryptionPort)
		}
		return nil
	})
}

// An object that represents a scheduling policy.
type SchedulingPolicyDetail struct {

	// The Amazon Resource Name (ARN) of the scheduling policy. An example is
	// arn:aws:batch:us-east-1:123456789012:scheduling-policy/HighPriority .
	//
	// This member is required.
	Arn *string

	// The name of the fair-share scheduling policy.
	//
	// This member is required.
	Name *string

	// The fair-share scheduling policy details.
	FairsharePolicy *FairsharePolicy

	// The quota share scheduling policy details.
	QuotaSharePolicy *QuotaSharePolicy

	// The tags that you apply to the fair-share scheduling policy to categorize and
	// organize your resources. Each tag consists of a key and an optional value. For
	// more information, see [Tagging Amazon Web Services resources]in Amazon Web Services General Reference.
	//
	// [Tagging Amazon Web Services resources]: https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html
	Tags map[string]string

	noSmithyDocumentSerde
}

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

func (v *SchedulingPolicyDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Arn != nil {
		s.WriteString(schemas.SchedulingPolicyDetail_arn, *v.Arn)
	}
	if v.FairsharePolicy != nil {
		s.WriteStruct(schemas.SchedulingPolicyDetail_fairsharePolicy)
		v.FairsharePolicy.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Name != nil {
		s.WriteString(schemas.SchedulingPolicyDetail_name, *v.Name)
	}
	if v.QuotaSharePolicy != nil {
		s.WriteStruct(schemas.SchedulingPolicyDetail_quotaSharePolicy)
		v.QuotaSharePolicy.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Tags != nil {
		serializeTagrisTagsMap(s, schemas.SchedulingPolicyDetail_tags, v.Tags)
	}
}
func (v *SchedulingPolicyDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.SchedulingPolicyDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.SchedulingPolicyDetail_arn:
			v.Arn = new(string)
			return d.ReadString(schemas.SchedulingPolicyDetail_arn, v.Arn)
		case schemas.SchedulingPolicyDetail_fairsharePolicy:
			v.FairsharePolicy = &FairsharePolicy{}
			return v.FairsharePolicy.Deserialize(d)
		case schemas.SchedulingPolicyDetail_name:
			v.Name = new(string)
			return d.ReadString(schemas.SchedulingPolicyDetail_name, v.Name)
		case schemas.SchedulingPolicyDetail_quotaSharePolicy:
			v.QuotaSharePolicy = &QuotaSharePolicy{}
			return v.QuotaSharePolicy.Deserialize(d)
		case schemas.SchedulingPolicyDetail_tags:
			return deserializeTagrisTagsMap(d, schemas.SchedulingPolicyDetail_tags, &v.Tags)
		}
		return nil
	})
}

// An object that contains the details of a scheduling policy that's returned in a
// ListSchedulingPolicy action.
type SchedulingPolicyListingDetail struct {

	// Amazon Resource Name (ARN) of the scheduling policy.
	//
	// This member is required.
	Arn *string

	noSmithyDocumentSerde
}

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

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

// An object that represents the secret to expose to your container. Secrets can
// be exposed to a container in the following ways:
//
//   - To inject sensitive data into your containers as environment variables, use
//     the secrets container definition parameter.
//
//   - To reference sensitive information in the log configuration of a container,
//     use the secretOptions container definition parameter.
//
// For more information, see [Specifying sensitive data] in the Batch User Guide.
//
// [Specifying sensitive data]: https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data.html
type Secret struct {

	// The name of the secret.
	//
	// This member is required.
	Name *string

	// The secret to expose to the container. The supported values are either the full
	// Amazon Resource Name (ARN) of the Secrets Manager secret or the full ARN of the
	// parameter in the Amazon Web Services Systems Manager Parameter Store.
	//
	// If the Amazon Web Services Systems Manager Parameter Store parameter exists in
	// the same Region as the job you're launching, then you can use either the full
	// Amazon Resource Name (ARN) or name of the parameter. If the parameter exists in
	// a different Region, then the full ARN must be specified.
	//
	// This member is required.
	ValueFrom *string

	noSmithyDocumentSerde
}

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

func (v *Secret) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Name != nil {
		s.WriteString(schemas.Secret_name, *v.Name)
	}
	if v.ValueFrom != nil {
		s.WriteString(schemas.Secret_valueFrom, *v.ValueFrom)
	}
}
func (v *Secret) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Secret, func(s *smithy.Schema) error {
		switch s {
		case schemas.Secret_name:
			v.Name = new(string)
			return d.ReadString(schemas.Secret_name, v.Name)
		case schemas.Secret_valueFrom:
			v.ValueFrom = new(string)
			return d.ReadString(schemas.Secret_valueFrom, v.ValueFrom)
		}
		return nil
	})
}

// Detailed information about a service environment, including its configuration,
// state, and capacity limits.
type ServiceEnvironmentDetail struct {

	// The capacity limits for the service environment. This defines the maximum
	// resources that can be used by service jobs in this environment.
	//
	// This member is required.
	CapacityLimits []CapacityLimit

	// The Amazon Resource Name (ARN) of the service environment.
	//
	// This member is required.
	ServiceEnvironmentArn *string

	// The name of the service environment.
	//
	// This member is required.
	ServiceEnvironmentName *string

	// The type of service environment. For SageMaker Training jobs, this value is
	// SAGEMAKER_TRAINING .
	//
	// This member is required.
	ServiceEnvironmentType ServiceEnvironmentType

	// The state of the service environment. Valid values are ENABLED and DISABLED .
	State ServiceEnvironmentState

	// The current status of the service environment.
	Status ServiceEnvironmentStatus

	// The tags associated with the service environment. Each tag consists of a key
	// and an optional value. For more information, see [Tagging your Batch resources].
	//
	// [Tagging your Batch resources]: https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html
	Tags map[string]string

	noSmithyDocumentSerde
}

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

func (v *ServiceEnvironmentDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityLimits != nil {
		serializeCapacityLimits(s, schemas.ServiceEnvironmentDetail_capacityLimits, v.CapacityLimits)
	}
	if v.ServiceEnvironmentArn != nil {
		s.WriteString(schemas.ServiceEnvironmentDetail_serviceEnvironmentArn, *v.ServiceEnvironmentArn)
	}
	if v.ServiceEnvironmentName != nil {
		s.WriteString(schemas.ServiceEnvironmentDetail_serviceEnvironmentName, *v.ServiceEnvironmentName)
	}
	if v.ServiceEnvironmentType != "" {
		s.WriteString(schemas.ServiceEnvironmentDetail_serviceEnvironmentType, string(v.ServiceEnvironmentType))
	}
	if v.State != "" {
		s.WriteString(schemas.ServiceEnvironmentDetail_state, string(v.State))
	}
	if v.Status != "" {
		s.WriteString(schemas.ServiceEnvironmentDetail_status, string(v.Status))
	}
	if v.Tags != nil {
		serializeTagrisTagsMap(s, schemas.ServiceEnvironmentDetail_tags, v.Tags)
	}
}
func (v *ServiceEnvironmentDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceEnvironmentDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceEnvironmentDetail_capacityLimits:
			return deserializeCapacityLimits(d, schemas.ServiceEnvironmentDetail_capacityLimits, &v.CapacityLimits)
		case schemas.ServiceEnvironmentDetail_serviceEnvironmentArn:
			v.ServiceEnvironmentArn = new(string)
			return d.ReadString(schemas.ServiceEnvironmentDetail_serviceEnvironmentArn, v.ServiceEnvironmentArn)
		case schemas.ServiceEnvironmentDetail_serviceEnvironmentName:
			v.ServiceEnvironmentName = new(string)
			return d.ReadString(schemas.ServiceEnvironmentDetail_serviceEnvironmentName, v.ServiceEnvironmentName)
		case schemas.ServiceEnvironmentDetail_serviceEnvironmentType:
			var ev string
			if err := d.ReadString(schemas.ServiceEnvironmentDetail_serviceEnvironmentType, &ev); err != nil {
				return err
			}
			v.ServiceEnvironmentType = ServiceEnvironmentType(ev)
			return nil
		case schemas.ServiceEnvironmentDetail_state:
			var ev string
			if err := d.ReadString(schemas.ServiceEnvironmentDetail_state, &ev); err != nil {
				return err
			}
			v.State = ServiceEnvironmentState(ev)
			return nil
		case schemas.ServiceEnvironmentDetail_status:
			var ev string
			if err := d.ReadString(schemas.ServiceEnvironmentDetail_status, &ev); err != nil {
				return err
			}
			v.Status = ServiceEnvironmentStatus(ev)
			return nil
		case schemas.ServiceEnvironmentDetail_tags:
			return deserializeTagrisTagsMap(d, schemas.ServiceEnvironmentDetail_tags, &v.Tags)
		}
		return nil
	})
}

// Specifies the order of a service environment for a job queue. This determines
// the priority order when multiple service environments are associated with the
// same job queue.
type ServiceEnvironmentOrder struct {

	// The order of the service environment. Job queues with a higher priority are
	// evaluated first when associated with the same service environment.
	//
	// This member is required.
	Order *int32

	// The name or ARN of the service environment.
	//
	// This member is required.
	ServiceEnvironment *string

	noSmithyDocumentSerde
}

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

func (v *ServiceEnvironmentOrder) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Order != nil {
		s.WriteInt32(schemas.ServiceEnvironmentOrder_order, *v.Order)
	}
	if v.ServiceEnvironment != nil {
		s.WriteString(schemas.ServiceEnvironmentOrder_serviceEnvironment, *v.ServiceEnvironment)
	}
}
func (v *ServiceEnvironmentOrder) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceEnvironmentOrder, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceEnvironmentOrder_order:
			v.Order = new(int32)
			return d.ReadInt32(schemas.ServiceEnvironmentOrder_order, v.Order)
		case schemas.ServiceEnvironmentOrder_serviceEnvironment:
			v.ServiceEnvironment = new(string)
			return d.ReadString(schemas.ServiceEnvironmentOrder_serviceEnvironment, v.ServiceEnvironment)
		}
		return nil
	})
}

// Detailed information about an attempt to run a service job.
type ServiceJobAttemptDetail struct {

	// The service resource identifier associated with the service job attempt.
	ServiceResourceId *ServiceResourceId

	// The Unix timestamp (in milliseconds) for when the service job attempt was
	// started.
	StartedAt *int64

	// A string that provides additional details for the current status of the service
	// job attempt.
	StatusReason *string

	// The Unix timestamp (in milliseconds) for when the service job attempt stopped
	// running.
	StoppedAt *int64

	noSmithyDocumentSerde
}

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

func (v *ServiceJobAttemptDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ServiceResourceId != nil {
		s.WriteStruct(schemas.ServiceJobAttemptDetail_serviceResourceId)
		v.ServiceResourceId.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.StartedAt != nil {
		s.WriteInt64(schemas.ServiceJobAttemptDetail_startedAt, *v.StartedAt)
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.ServiceJobAttemptDetail_statusReason, *v.StatusReason)
	}
	if v.StoppedAt != nil {
		s.WriteInt64(schemas.ServiceJobAttemptDetail_stoppedAt, *v.StoppedAt)
	}
}
func (v *ServiceJobAttemptDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceJobAttemptDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceJobAttemptDetail_serviceResourceId:
			v.ServiceResourceId = &ServiceResourceId{}
			return v.ServiceResourceId.Deserialize(d)
		case schemas.ServiceJobAttemptDetail_startedAt:
			v.StartedAt = new(int64)
			return d.ReadInt64(schemas.ServiceJobAttemptDetail_startedAt, v.StartedAt)
		case schemas.ServiceJobAttemptDetail_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.ServiceJobAttemptDetail_statusReason, v.StatusReason)
		case schemas.ServiceJobAttemptDetail_stoppedAt:
			v.StoppedAt = new(int64)
			return d.ReadInt64(schemas.ServiceJobAttemptDetail_stoppedAt, v.StoppedAt)
		}
		return nil
	})
}

// The capacity usage for a service job, including the unit of measure and
// quantity of resources being consumed.
type ServiceJobCapacityUsageDetail struct {

	// The unit of measure for the service job capacity usage. For service jobs, this
	// is the instance type.
	CapacityUnit *string

	// The quantity of capacity being used by the service job, measured in the units
	// specified by capacityUnit .
	Quantity *float64

	noSmithyDocumentSerde
}

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

func (v *ServiceJobCapacityUsageDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUnit != nil {
		s.WriteString(schemas.ServiceJobCapacityUsageDetail_capacityUnit, *v.CapacityUnit)
	}
	if v.Quantity != nil {
		s.WriteFloat64(schemas.ServiceJobCapacityUsageDetail_quantity, *v.Quantity)
	}
}
func (v *ServiceJobCapacityUsageDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceJobCapacityUsageDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceJobCapacityUsageDetail_capacityUnit:
			v.CapacityUnit = new(string)
			return d.ReadString(schemas.ServiceJobCapacityUsageDetail_capacityUnit, v.CapacityUnit)
		case schemas.ServiceJobCapacityUsageDetail_quantity:
			v.Quantity = new(float64)
			return d.ReadFloat64(schemas.ServiceJobCapacityUsageDetail_quantity, v.Quantity)
		}
		return nil
	})
}

// The capacity usage for a service job, including the unit of measure and
// quantity of resources being used.
type ServiceJobCapacityUsageSummary struct {

	// The unit of measure for the service job capacity usage. For service jobs, this
	// is the instance type.
	CapacityUnit *string

	// The quantity of capacity being used by the service job, measured in the units
	// specified by capacityUnit .
	Quantity *float64

	noSmithyDocumentSerde
}

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

func (v *ServiceJobCapacityUsageSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUnit != nil {
		s.WriteString(schemas.ServiceJobCapacityUsageSummary_capacityUnit, *v.CapacityUnit)
	}
	if v.Quantity != nil {
		s.WriteFloat64(schemas.ServiceJobCapacityUsageSummary_quantity, *v.Quantity)
	}
}
func (v *ServiceJobCapacityUsageSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceJobCapacityUsageSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceJobCapacityUsageSummary_capacityUnit:
			v.CapacityUnit = new(string)
			return d.ReadString(schemas.ServiceJobCapacityUsageSummary_capacityUnit, v.CapacityUnit)
		case schemas.ServiceJobCapacityUsageSummary_quantity:
			v.Quantity = new(float64)
			return d.ReadFloat64(schemas.ServiceJobCapacityUsageSummary_quantity, v.Quantity)
		}
		return nil
	})
}

// Specifies conditions for when to exit or retry a service job based on the exit
// status or status reason.
type ServiceJobEvaluateOnExit struct {

	// The action to take if the service job exits with the specified condition. Valid
	// values are RETRY and EXIT .
	Action ServiceJobRetryAction

	// Contains a glob pattern to match against the StatusReason returned for a job.
	// The pattern can contain up to 512 characters and can contain all printable
	// characters. It can optionally end with an asterisk (*) so that only the start of
	// the string needs to be an exact match.
	OnStatusReason *string

	noSmithyDocumentSerde
}

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

func (v *ServiceJobEvaluateOnExit) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Action != "" {
		s.WriteString(schemas.ServiceJobEvaluateOnExit_action, string(v.Action))
	}
	if v.OnStatusReason != nil {
		s.WriteString(schemas.ServiceJobEvaluateOnExit_onStatusReason, *v.OnStatusReason)
	}
}
func (v *ServiceJobEvaluateOnExit) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceJobEvaluateOnExit, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceJobEvaluateOnExit_action:
			var ev string
			if err := d.ReadString(schemas.ServiceJobEvaluateOnExit_action, &ev); err != nil {
				return err
			}
			v.Action = ServiceJobRetryAction(ev)
			return nil
		case schemas.ServiceJobEvaluateOnExit_onStatusReason:
			v.OnStatusReason = new(string)
			return d.ReadString(schemas.ServiceJobEvaluateOnExit_onStatusReason, v.OnStatusReason)
		}
		return nil
	})
}

// Detailed information about a preempted attempt of a service job.
type ServiceJobPreemptedAttempt struct {

	// The service resource identifier associated with the service job attempt.
	ServiceResourceId *ServiceResourceId

	// The Unix timestamp (in milliseconds) for when the service job attempt was
	// started.
	StartedAt *int64

	// A string that provides additional details for the current status of the service
	// job attempt.
	StatusReason *string

	// The Unix timestamp (in milliseconds) for when the service job attempt stopped
	// running.
	StoppedAt *int64

	noSmithyDocumentSerde
}

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

func (v *ServiceJobPreemptedAttempt) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ServiceResourceId != nil {
		s.WriteStruct(schemas.ServiceJobPreemptedAttempt_serviceResourceId)
		v.ServiceResourceId.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.StartedAt != nil {
		s.WriteInt64(schemas.ServiceJobPreemptedAttempt_startedAt, *v.StartedAt)
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.ServiceJobPreemptedAttempt_statusReason, *v.StatusReason)
	}
	if v.StoppedAt != nil {
		s.WriteInt64(schemas.ServiceJobPreemptedAttempt_stoppedAt, *v.StoppedAt)
	}
}
func (v *ServiceJobPreemptedAttempt) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceJobPreemptedAttempt, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceJobPreemptedAttempt_serviceResourceId:
			v.ServiceResourceId = &ServiceResourceId{}
			return v.ServiceResourceId.Deserialize(d)
		case schemas.ServiceJobPreemptedAttempt_startedAt:
			v.StartedAt = new(int64)
			return d.ReadInt64(schemas.ServiceJobPreemptedAttempt_startedAt, v.StartedAt)
		case schemas.ServiceJobPreemptedAttempt_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.ServiceJobPreemptedAttempt_statusReason, v.StatusReason)
		case schemas.ServiceJobPreemptedAttempt_stoppedAt:
			v.StoppedAt = new(int64)
			return d.ReadInt64(schemas.ServiceJobPreemptedAttempt_stoppedAt, v.StoppedAt)
		}
		return nil
	})
}

// Specifies the service job behavior when preempted.
type ServiceJobPreemptionConfiguration struct {

	// The number of times a service job can be retried after it is preempted. A job
	// will be terminated when preemption retries have been exhausted. If this field is
	// unset, preempted jobs will be requeued an unlimited number of times.
	PreemptionRetriesBeforeTermination *int32

	noSmithyDocumentSerde
}

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

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

// Summarizes the preemptions of the service job. This field appears on a service
// job when it has been preempted.
type ServiceJobPreemptionSummary struct {

	// The total number of times the service job has been preempted.
	PreemptedAttemptCount *int32

	// A list of the most recent preemption attempts for the service job.
	RecentPreemptedAttempts []ServiceJobPreemptedAttempt

	noSmithyDocumentSerde
}

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

func (v *ServiceJobPreemptionSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.PreemptedAttemptCount != nil {
		s.WriteInt32(schemas.ServiceJobPreemptionSummary_preemptedAttemptCount, *v.PreemptedAttemptCount)
	}
	if v.RecentPreemptedAttempts != nil {
		serializeServiceJobRecentPreemptedAttemptList(s, schemas.ServiceJobPreemptionSummary_recentPreemptedAttempts, v.RecentPreemptedAttempts)
	}
}
func (v *ServiceJobPreemptionSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceJobPreemptionSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceJobPreemptionSummary_preemptedAttemptCount:
			v.PreemptedAttemptCount = new(int32)
			return d.ReadInt32(schemas.ServiceJobPreemptionSummary_preemptedAttemptCount, v.PreemptedAttemptCount)
		case schemas.ServiceJobPreemptionSummary_recentPreemptedAttempts:
			return deserializeServiceJobRecentPreemptedAttemptList(d, schemas.ServiceJobPreemptionSummary_recentPreemptedAttempts, &v.RecentPreemptedAttempts)
		}
		return nil
	})
}

// The retry strategy for service jobs. This defines how many times to retry a
// failed service job and under what conditions. For more information, see [Service job retry strategies]in the
// Batch User Guide.
//
// [Service job retry strategies]: https://docs.aws.amazon.com/batch/latest/userguide/service-job-retries.html
type ServiceJobRetryStrategy struct {

	// The number of times to move a service job to RUNNABLE status. You can specify
	// between 1 and 10 attempts.
	//
	// This member is required.
	Attempts *int32

	// Array of ServiceJobEvaluateOnExit objects that specify conditions under which
	// the service job should be retried or failed.
	EvaluateOnExit []ServiceJobEvaluateOnExit

	noSmithyDocumentSerde
}

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

func (v *ServiceJobRetryStrategy) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Attempts != nil {
		s.WriteInt32(schemas.ServiceJobRetryStrategy_attempts, *v.Attempts)
	}
	if v.EvaluateOnExit != nil {
		serializeServiceJobEvaluateOnExitList(s, schemas.ServiceJobRetryStrategy_evaluateOnExit, v.EvaluateOnExit)
	}
}
func (v *ServiceJobRetryStrategy) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceJobRetryStrategy, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceJobRetryStrategy_attempts:
			v.Attempts = new(int32)
			return d.ReadInt32(schemas.ServiceJobRetryStrategy_attempts, v.Attempts)
		case schemas.ServiceJobRetryStrategy_evaluateOnExit:
			return deserializeServiceJobEvaluateOnExitList(d, schemas.ServiceJobRetryStrategy_evaluateOnExit, &v.EvaluateOnExit)
		}
		return nil
	})
}

// Summary information about a service job.
type ServiceJobSummary struct {

	// The job ID for the service job.
	//
	// This member is required.
	JobId *string

	// The name of the service job.
	//
	// This member is required.
	JobName *string

	// The type of service job. For SageMaker Training jobs, this value is
	// SAGEMAKER_TRAINING .
	//
	// This member is required.
	ServiceJobType ServiceJobType

	// The capacity usage information for this service job, including the unit of
	// measure and quantity of resources being used.
	CapacityUsage []ServiceJobCapacityUsageSummary

	// The Unix timestamp (in milliseconds) for when the service job was created.
	CreatedAt *int64

	// Indicates whether a termination request has been accepted for the service job.
	// This field is only present when the value is true .
	IsTerminated *bool

	// The Amazon Resource Name (ARN) of the service job.
	JobArn *string

	// Information about the latest attempt for the service job.
	LatestAttempt *LatestServiceJobAttempt

	// The quota share for the service job.
	QuotaShareName *string

	// The Unix timestamp (in milliseconds) for when the service job was scheduled for
	// execution.
	ScheduledAt *int64

	// The share identifier for the job.
	ShareIdentifier *string

	// The Unix timestamp (in milliseconds) for when the service job was started.
	StartedAt *int64

	// The current status of the service job.
	Status ServiceJobStatus

	// A short string to provide more details on the current status of the service job.
	StatusReason *string

	// The Unix timestamp (in milliseconds) for when the service job stopped running.
	StoppedAt *int64

	noSmithyDocumentSerde
}

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

func (v *ServiceJobSummary) SerializeMembers(s smithy.ShapeSerializer) {
	if v.CapacityUsage != nil {
		serializeServiceJobCapacityUsageSummaryList(s, schemas.ServiceJobSummary_capacityUsage, v.CapacityUsage)
	}
	if v.CreatedAt != nil {
		s.WriteInt64(schemas.ServiceJobSummary_createdAt, *v.CreatedAt)
	}
	if v.IsTerminated != nil {
		s.WriteBool(schemas.ServiceJobSummary_isTerminated, *v.IsTerminated)
	}
	if v.JobArn != nil {
		s.WriteString(schemas.ServiceJobSummary_jobArn, *v.JobArn)
	}
	if v.JobId != nil {
		s.WriteString(schemas.ServiceJobSummary_jobId, *v.JobId)
	}
	if v.JobName != nil {
		s.WriteString(schemas.ServiceJobSummary_jobName, *v.JobName)
	}
	if v.LatestAttempt != nil {
		s.WriteStruct(schemas.ServiceJobSummary_latestAttempt)
		v.LatestAttempt.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.QuotaShareName != nil {
		s.WriteString(schemas.ServiceJobSummary_quotaShareName, *v.QuotaShareName)
	}
	if v.ScheduledAt != nil {
		s.WriteInt64(schemas.ServiceJobSummary_scheduledAt, *v.ScheduledAt)
	}
	if v.ServiceJobType != "" {
		s.WriteString(schemas.ServiceJobSummary_serviceJobType, string(v.ServiceJobType))
	}
	if v.ShareIdentifier != nil {
		s.WriteString(schemas.ServiceJobSummary_shareIdentifier, *v.ShareIdentifier)
	}
	if v.StartedAt != nil {
		s.WriteInt64(schemas.ServiceJobSummary_startedAt, *v.StartedAt)
	}
	if v.Status != "" {
		s.WriteString(schemas.ServiceJobSummary_status, string(v.Status))
	}
	if v.StatusReason != nil {
		s.WriteString(schemas.ServiceJobSummary_statusReason, *v.StatusReason)
	}
	if v.StoppedAt != nil {
		s.WriteInt64(schemas.ServiceJobSummary_stoppedAt, *v.StoppedAt)
	}
}
func (v *ServiceJobSummary) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ServiceJobSummary, func(s *smithy.Schema) error {
		switch s {
		case schemas.ServiceJobSummary_capacityUsage:
			return deserializeServiceJobCapacityUsageSummaryList(d, schemas.ServiceJobSummary_capacityUsage, &v.CapacityUsage)
		case schemas.ServiceJobSummary_createdAt:
			v.CreatedAt = new(int64)
			return d.ReadInt64(schemas.ServiceJobSummary_createdAt, v.CreatedAt)
		case schemas.ServiceJobSummary_isTerminated:
			v.IsTerminated = new(bool)
			return d.ReadBool(schemas.ServiceJobSummary_isTerminated, v.IsTerminated)
		case schemas.ServiceJobSummary_jobArn:
			v.JobArn = new(string)
			return d.ReadString(schemas.ServiceJobSummary_jobArn, v.JobArn)
		case schemas.ServiceJobSummary_jobId:
			v.JobId = new(string)
			return d.ReadString(schemas.ServiceJobSummary_jobId, v.JobId)
		case schemas.ServiceJobSummary_jobName:
			v.JobName = new(string)
			return d.ReadString(schemas.ServiceJobSummary_jobName, v.JobName)
		case schemas.ServiceJobSummary_latestAttempt:
			v.LatestAttempt = &LatestServiceJobAttempt{}
			return v.LatestAttempt.Deserialize(d)
		case schemas.ServiceJobSummary_quotaShareName:
			v.QuotaShareName = new(string)
			return d.ReadString(schemas.ServiceJobSummary_quotaShareName, v.QuotaShareName)
		case schemas.ServiceJobSummary_scheduledAt:
			v.ScheduledAt = new(int64)
			return d.ReadInt64(schemas.ServiceJobSummary_scheduledAt, v.ScheduledAt)
		case schemas.ServiceJobSummary_serviceJobType:
			var ev string
			if err := d.ReadString(schemas.ServiceJobSummary_serviceJobType, &ev); err != nil {
				return err
			}
			v.ServiceJobType = ServiceJobType(ev)
			return nil
		case schemas.ServiceJobSummary_shareIdentifier:
			v.ShareIdentifier = new(string)
			return d.ReadString(schemas.ServiceJobSummary_shareIdentifier, v.ShareIdentifier)
		case schemas.ServiceJobSummary_startedAt:
			v.StartedAt = new(int64)
			return d.ReadInt64(schemas.ServiceJobSummary_startedAt, v.StartedAt)
		case schemas.ServiceJobSummary_status:
			var ev string
			if err := d.ReadString(schemas.ServiceJobSummary_status, &ev); err != nil {
				return err
			}
			v.Status = ServiceJobStatus(ev)
			return nil
		case schemas.ServiceJobSummary_statusReason:
			v.StatusReason = new(string)
			return d.ReadString(schemas.ServiceJobSummary_statusReason, v.StatusReason)
		case schemas.ServiceJobSummary_stoppedAt:
			v.StoppedAt = new(int64)
			return d.ReadInt64(schemas.ServiceJobSummary_stoppedAt, v.StoppedAt)
		}
		return nil
	})
}

// The timeout configuration for service jobs.
type ServiceJobTimeout struct {

	// The maximum duration in seconds that a service job attempt can run. After this
	// time is reached, Batch terminates the service job attempt.
	AttemptDurationSeconds *int32

	noSmithyDocumentSerde
}

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

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

// The Batch unique identifier.
type ServiceResourceId struct {

	// The name of the resource identifier.
	//
	// This member is required.
	Name ServiceResourceIdName

	// The value of the resource identifier.
	//
	// This member is required.
	Value *string

	noSmithyDocumentSerde
}

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

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

// Specifies the weights for the share identifiers for the fair-share policy.
// Share identifiers that aren't included have a default weight of 1.0 .
type ShareAttributes struct {

	// A share identifier or share identifier prefix. If the string ends with an
	// asterisk (*), this entry specifies the weight factor to use for share
	// identifiers that start with that prefix. The list of share identifiers in a
	// fair-share policy can't overlap. For example, you can't have one that specifies
	// a shareIdentifier of UserA* and another that specifies a shareIdentifier of
	// UserA1 .
	//
	// There can be no more than 500 share identifiers active in a job queue.
	//
	// The string is limited to 255 alphanumeric characters, and can be followed by an
	// asterisk (*).
	//
	// This member is required.
	ShareIdentifier *string

	// The weight factor for the share identifier. The default value is 1.0. A lower
	// value has a higher priority for compute resources. For example, jobs that use a
	// share identifier with a weight factor of 0.125 (1/8) get 8 times the compute
	// resources of jobs that use a share identifier with a weight factor of 1.
	//
	// The smallest supported value is 0.0001, and the largest supported value is
	// 999.9999.
	WeightFactor *float32

	noSmithyDocumentSerde
}

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

func (v *ShareAttributes) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ShareIdentifier != nil {
		s.WriteString(schemas.ShareAttributes_shareIdentifier, *v.ShareIdentifier)
	}
	if v.WeightFactor != nil {
		s.WriteFloat32(schemas.ShareAttributes_weightFactor, *v.WeightFactor)
	}
}
func (v *ShareAttributes) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.ShareAttributes, func(s *smithy.Schema) error {
		switch s {
		case schemas.ShareAttributes_shareIdentifier:
			v.ShareIdentifier = new(string)
			return d.ReadString(schemas.ShareAttributes_shareIdentifier, v.ShareIdentifier)
		case schemas.ShareAttributes_weightFactor:
			v.WeightFactor = new(float32)
			return d.ReadFloat32(schemas.ShareAttributes_weightFactor, v.WeightFactor)
		}
		return nil
	})
}

// A list of containers that this task depends on.
type TaskContainerDependency struct {

	// The dependency condition of the container. The following are the available
	// conditions and their behavior:
	//
	//   - START - This condition emulates the behavior of links and volumes today. It
	//   validates that a dependent container is started before permitting other
	//   containers to start.
	//
	//   - COMPLETE - This condition validates that a dependent container runs to
	//   completion (exits) before permitting other containers to start. This can be
	//   useful for nonessential containers that run a script and then exit. This
	//   condition can't be set on an essential container.
	//
	//   - SUCCESS - This condition is the same as COMPLETE , but it also requires that
	//   the container exits with a zero status. This condition can't be set on an
	//   essential container.
	Condition *string

	// A unique identifier for the container.
	ContainerName *string

	noSmithyDocumentSerde
}

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

func (v *TaskContainerDependency) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Condition != nil {
		s.WriteString(schemas.TaskContainerDependency_condition, *v.Condition)
	}
	if v.ContainerName != nil {
		s.WriteString(schemas.TaskContainerDependency_containerName, *v.ContainerName)
	}
}
func (v *TaskContainerDependency) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.TaskContainerDependency, func(s *smithy.Schema) error {
		switch s {
		case schemas.TaskContainerDependency_condition:
			v.Condition = new(string)
			return d.ReadString(schemas.TaskContainerDependency_condition, v.Condition)
		case schemas.TaskContainerDependency_containerName:
			v.ContainerName = new(string)
			return d.ReadString(schemas.TaskContainerDependency_containerName, v.ContainerName)
		}
		return nil
	})
}

// The details for the container in this task attempt.
type TaskContainerDetails struct {

	// The command that's passed to the container. This parameter maps to Cmd in the [Create a container]
	// section of the [Docker Remote API]and the COMMAND parameter to [docker run]. For more information, see [https://docs.docker.com/engine/reference/builder/#cmd].
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	// [https://docs.docker.com/engine/reference/builder/#cmd]: https://docs.docker.com/engine/reference/builder/#cmd
	Command []string

	// A list of containers that this container depends on.
	DependsOn []TaskContainerDependency

	// The environment variables to pass to a container. This parameter maps to Env in
	// the [Create a container]section of the [Docker Remote API] and the --env option to [docker run].
	//
	// We don't recommend using plaintext environment variables for sensitive
	// information, such as credential data.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Environment []KeyValuePair

	// If the essential parameter of a container is marked as true , and that container
	// fails or stops for any reason, all other containers that are part of the task
	// are stopped. If the essential parameter of a container is marked as false, its
	// failure doesn't affect the rest of the containers in a task. If this parameter
	// is omitted, a container is assumed to be essential.
	//
	// All jobs must have at least one essential container. If you have an application
	// that's composed of multiple containers, group containers that are used for a
	// common purpose into components, and separate the different components into
	// multiple task definitions. For more information, see [Application Architecture]in the Amazon Elastic
	// Container Service Developer Guide.
	//
	// [Application Architecture]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html
	Essential *bool

	// The exit code returned upon completion.
	ExitCode *int32

	// The FireLens configuration for the container. This is used to specify and
	// configure a log router for container logs. For more information, see [Custom log]routing in
	// the Amazon Elastic Container Service Developer Guide.
	//
	// [Custom log]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html
	FirelensConfiguration *FirelensConfiguration

	// The image used to start a container. This string is passed directly to the
	// Docker daemon. By default, images in the Docker Hub registry are available.
	// Other repositories are specified with either repository-url/image:tag or
	// repository-url/image@digest . Up to 255 letters (uppercase and lowercase),
	// numbers, hyphens, underscores, colons, periods, forward slashes, and number
	// signs are allowed. This parameter maps to Image in the [Create a container] section of the [Docker Remote API] and the
	// IMAGE parameter of the [docker run].
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Image *string

	// Linux-specific modifications that are applied to the container, such as Linux
	// kernel capabilities. For more information, see [KernelCapabilities].
	//
	// This parameter is not supported for Windows containers.
	//
	// [KernelCapabilities]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html
	LinuxParameters *LinuxParameters

	// The log configuration specification for the container.
	//
	// This parameter maps to LogConfig in the [Create a container] section of the [Docker Remote API] and the --log-driver
	// option to [docker run].
	//
	// By default, containers use the same logging driver that the Docker daemon uses.
	// However the container can use a different logging driver than the Docker daemon
	// by specifying a log driver with this parameter in the container definition. To
	// use a different logging driver for a container, the log system must be
	// configured properly on the container instance (or on a different log server for
	// remote logging options). For more information about the options for different
	// supported log drivers, see [Configure logging drivers]in the Docker documentation.
	//
	// Amazon ECS currently supports a subset of the logging drivers available to the
	// Docker daemon (shown in the LogConfiguration data type). Additional log drivers
	// may be available in future releases of the Amazon ECS container agent.
	//
	// This parameter requires version 1.18 of the Docker Remote API or greater on
	// your container instance. To check the Docker Remote API version on your
	// container instance, log in to your container instance and run the following
	// command: sudo docker version --format '{{.Server.APIVersion}}'
	//
	// The Amazon ECS container agent running on a container instance must register
	// the logging drivers available on that instance with the
	// ECS_AVAILABLE_LOGGING_DRIVERS environment variable before containers placed on
	// that instance can use these log configuration options. For more information, see
	// [Amazon ECS container agent configuration]in the Amazon Elastic Container Service Developer Guide.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Configure logging drivers]: https://docs.docker.com/engine/admin/logging/overview/
	// [Amazon ECS container agent configuration]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	LogConfiguration *LogConfiguration

	// The name of the CloudWatch Logs log stream that's associated with the
	// container. The log group for Batch jobs is /aws/batch/job. Each container
	// attempt receives a log stream name when they reach the RUNNING status.
	LogStreamName *string

	// The mount points for data volumes in your container.
	//
	// This parameter maps to Volumes in the [Create a container] section of the [Docker Remote API] and the --volume option to [docker run].
	//
	// Windows containers can mount whole directories on the same drive as
	// $env:ProgramData . Windows containers can't mount directories on a different
	// drive, and mount point can't be across drives.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	MountPoints []MountPoint

	// The name of a container.
	Name *string

	// The network interfaces that are associated with the job.
	NetworkInterfaces []NetworkInterface

	// When this parameter is true , the container is given elevated privileges on the
	// host container instance (similar to the root user). This parameter maps to
	// Privileged in the [Create a container] section of the [Docker Remote API] and the --privileged option to [docker run].
	//
	// This parameter is not supported for Windows containers or tasks run on Fargate.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Privileged *bool

	// When this parameter is true, the container is given read-only access to its
	// root file system. This parameter maps to ReadonlyRootfs in the [Create a container] section of the [Docker Remote API]
	// and the --read-only option to [docker run].
	//
	// This parameter is not supported for Windows containers.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	ReadonlyRootFilesystem *bool

	// A short (255 max characters) human-readable string to provide additional
	// details for a running or stopped container.
	Reason *string

	// The private repository authentication credentials to use.
	RepositoryCredentials *RepositoryCredentials

	// The type and amount of a resource to assign to a container. The only supported
	// resource is a GPU.
	ResourceRequirements []ResourceRequirement

	// The secrets to pass to the container. For more information, see [Specifying Sensitive Data] in the Amazon
	// Elastic Container Service Developer Guide.
	//
	// [Specifying Sensitive Data]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html
	Secrets []Secret

	// Time duration (in seconds) to wait before giving up on resolving dependencies
	// for a container. The minimum value is 2 seconds and the maximum value for
	// Fargate is 120 seconds.
	StartTimeout *int32

	// Time duration (in seconds) to wait before the container is forcefully killed if
	// it doesn't exit normally on its own. The minimum value is 2 seconds and the
	// maximum value for Fargate is 120 seconds. If the parameter is not specified, the
	// default value of 30 seconds is used. For tasks that use the EC2 launch type, if
	// the stopTimeout parameter isn't specified, the value set for the Amazon ECS
	// container agent configuration variable ECS_CONTAINER_STOP_TIMEOUT is used. If
	// neither the stopTimeout parameter nor the ECS_CONTAINER_STOP_TIMEOUT agent
	// configuration variable are set, then the default value of 30 seconds is used.
	StopTimeout *int32

	// A list of ulimits to set in the container. If a ulimit value is specified in a
	// task definition, it overrides the default values set by Docker. This parameter
	// maps to Ulimits in the [Create a container] section of the [Docker Remote API] and the --ulimit option to [docker run].
	//
	// Amazon ECS tasks hosted on Fargate use the default resource limit values set by
	// the operating system with the exception of the nofile resource limit parameter
	// which Fargate overrides. The nofile resource limit sets a restriction on the
	// number of open files that a container can use. The default nofile soft limit is
	// 1024 and the default hard limit is 65535 .
	//
	// This parameter requires version 1.18 of the Docker Remote API or greater on
	// your container instance. To check the Docker Remote API version on your
	// container instance, log in to your container instance and run the following
	// command: sudo docker version --format '{{.Server.APIVersion}}'
	//
	// This parameter is not supported for Windows containers.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Ulimits []Ulimit

	// The user to use inside the container. This parameter maps to User in the Create
	// a container section of the Docker Remote API and the --user option to docker
	// run.
	//
	// When running tasks using the host network mode, don't run containers using the
	// root user (UID 0) . We recommend using a non-root user for better security.
	//
	// You can specify the user using the following formats. If specifying a UID or
	// GID, you must specify it as a positive integer.
	//
	//   - user
	//
	//   - user:group
	//
	//   - uid
	//
	//   - uid:gid
	//
	//   - user:gi
	//
	//   - uid:group
	//
	// This parameter is not supported for Windows containers.
	User *string

	noSmithyDocumentSerde
}

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

func (v *TaskContainerDetails) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Command != nil {
		serializeStringList(s, schemas.TaskContainerDetails_command, v.Command)
	}
	if v.DependsOn != nil {
		serializeTaskContainerDependencyList(s, schemas.TaskContainerDetails_dependsOn, v.DependsOn)
	}
	if v.Environment != nil {
		serializeEnvironmentVariables(s, schemas.TaskContainerDetails_environment, v.Environment)
	}
	if v.Essential != nil {
		s.WriteBool(schemas.TaskContainerDetails_essential, *v.Essential)
	}
	if v.ExitCode != nil {
		s.WriteInt32(schemas.TaskContainerDetails_exitCode, *v.ExitCode)
	}
	if v.FirelensConfiguration != nil {
		s.WriteStruct(schemas.TaskContainerDetails_firelensConfiguration)
		v.FirelensConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Image != nil {
		s.WriteString(schemas.TaskContainerDetails_image, *v.Image)
	}
	if v.LinuxParameters != nil {
		s.WriteStruct(schemas.TaskContainerDetails_linuxParameters)
		v.LinuxParameters.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LogConfiguration != nil {
		s.WriteStruct(schemas.TaskContainerDetails_logConfiguration)
		v.LogConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LogStreamName != nil {
		s.WriteString(schemas.TaskContainerDetails_logStreamName, *v.LogStreamName)
	}
	if v.MountPoints != nil {
		serializeMountPoints(s, schemas.TaskContainerDetails_mountPoints, v.MountPoints)
	}
	if v.Name != nil {
		s.WriteString(schemas.TaskContainerDetails_name, *v.Name)
	}
	if v.NetworkInterfaces != nil {
		serializeNetworkInterfaceList(s, schemas.TaskContainerDetails_networkInterfaces, v.NetworkInterfaces)
	}
	if v.Privileged != nil {
		s.WriteBool(schemas.TaskContainerDetails_privileged, *v.Privileged)
	}
	if v.ReadonlyRootFilesystem != nil {
		s.WriteBool(schemas.TaskContainerDetails_readonlyRootFilesystem, *v.ReadonlyRootFilesystem)
	}
	if v.Reason != nil {
		s.WriteString(schemas.TaskContainerDetails_reason, *v.Reason)
	}
	if v.RepositoryCredentials != nil {
		s.WriteStruct(schemas.TaskContainerDetails_repositoryCredentials)
		v.RepositoryCredentials.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ResourceRequirements != nil {
		serializeResourceRequirements(s, schemas.TaskContainerDetails_resourceRequirements, v.ResourceRequirements)
	}
	if v.Secrets != nil {
		serializeSecretList(s, schemas.TaskContainerDetails_secrets, v.Secrets)
	}
	if v.StartTimeout != nil {
		s.WriteInt32(schemas.TaskContainerDetails_startTimeout, *v.StartTimeout)
	}
	if v.StopTimeout != nil {
		s.WriteInt32(schemas.TaskContainerDetails_stopTimeout, *v.StopTimeout)
	}
	if v.Ulimits != nil {
		serializeUlimits(s, schemas.TaskContainerDetails_ulimits, v.Ulimits)
	}
	if v.User != nil {
		s.WriteString(schemas.TaskContainerDetails_user, *v.User)
	}
}
func (v *TaskContainerDetails) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.TaskContainerDetails, func(s *smithy.Schema) error {
		switch s {
		case schemas.TaskContainerDetails_command:
			return deserializeStringList(d, schemas.TaskContainerDetails_command, &v.Command)
		case schemas.TaskContainerDetails_dependsOn:
			return deserializeTaskContainerDependencyList(d, schemas.TaskContainerDetails_dependsOn, &v.DependsOn)
		case schemas.TaskContainerDetails_environment:
			return deserializeEnvironmentVariables(d, schemas.TaskContainerDetails_environment, &v.Environment)
		case schemas.TaskContainerDetails_essential:
			v.Essential = new(bool)
			return d.ReadBool(schemas.TaskContainerDetails_essential, v.Essential)
		case schemas.TaskContainerDetails_exitCode:
			v.ExitCode = new(int32)
			return d.ReadInt32(schemas.TaskContainerDetails_exitCode, v.ExitCode)
		case schemas.TaskContainerDetails_firelensConfiguration:
			v.FirelensConfiguration = &FirelensConfiguration{}
			return v.FirelensConfiguration.Deserialize(d)
		case schemas.TaskContainerDetails_image:
			v.Image = new(string)
			return d.ReadString(schemas.TaskContainerDetails_image, v.Image)
		case schemas.TaskContainerDetails_linuxParameters:
			v.LinuxParameters = &LinuxParameters{}
			return v.LinuxParameters.Deserialize(d)
		case schemas.TaskContainerDetails_logConfiguration:
			v.LogConfiguration = &LogConfiguration{}
			return v.LogConfiguration.Deserialize(d)
		case schemas.TaskContainerDetails_logStreamName:
			v.LogStreamName = new(string)
			return d.ReadString(schemas.TaskContainerDetails_logStreamName, v.LogStreamName)
		case schemas.TaskContainerDetails_mountPoints:
			return deserializeMountPoints(d, schemas.TaskContainerDetails_mountPoints, &v.MountPoints)
		case schemas.TaskContainerDetails_name:
			v.Name = new(string)
			return d.ReadString(schemas.TaskContainerDetails_name, v.Name)
		case schemas.TaskContainerDetails_networkInterfaces:
			return deserializeNetworkInterfaceList(d, schemas.TaskContainerDetails_networkInterfaces, &v.NetworkInterfaces)
		case schemas.TaskContainerDetails_privileged:
			v.Privileged = new(bool)
			return d.ReadBool(schemas.TaskContainerDetails_privileged, v.Privileged)
		case schemas.TaskContainerDetails_readonlyRootFilesystem:
			v.ReadonlyRootFilesystem = new(bool)
			return d.ReadBool(schemas.TaskContainerDetails_readonlyRootFilesystem, v.ReadonlyRootFilesystem)
		case schemas.TaskContainerDetails_reason:
			v.Reason = new(string)
			return d.ReadString(schemas.TaskContainerDetails_reason, v.Reason)
		case schemas.TaskContainerDetails_repositoryCredentials:
			v.RepositoryCredentials = &RepositoryCredentials{}
			return v.RepositoryCredentials.Deserialize(d)
		case schemas.TaskContainerDetails_resourceRequirements:
			return deserializeResourceRequirements(d, schemas.TaskContainerDetails_resourceRequirements, &v.ResourceRequirements)
		case schemas.TaskContainerDetails_secrets:
			return deserializeSecretList(d, schemas.TaskContainerDetails_secrets, &v.Secrets)
		case schemas.TaskContainerDetails_startTimeout:
			v.StartTimeout = new(int32)
			return d.ReadInt32(schemas.TaskContainerDetails_startTimeout, v.StartTimeout)
		case schemas.TaskContainerDetails_stopTimeout:
			v.StopTimeout = new(int32)
			return d.ReadInt32(schemas.TaskContainerDetails_stopTimeout, v.StopTimeout)
		case schemas.TaskContainerDetails_ulimits:
			return deserializeUlimits(d, schemas.TaskContainerDetails_ulimits, &v.Ulimits)
		case schemas.TaskContainerDetails_user:
			v.User = new(string)
			return d.ReadString(schemas.TaskContainerDetails_user, v.User)
		}
		return nil
	})
}

// The overrides that should be sent to a container.
//
// For information about using Batch overrides when you connect event sources to
// targets, see [BatchContainerOverrides].
//
// [BatchContainerOverrides]: https://docs.aws.amazon.com/eventbridge/latest/pipes-reference/API_BatchContainerOverrides.html
type TaskContainerOverrides struct {

	// The command to send to the container that overrides the default command from
	// the Docker image or the job definition.
	//
	// This parameter can't contain an empty string.
	Command []string

	// The environment variables to send to the container. You can add new environment
	// variables, which are added to the container at launch, or you can override the
	// existing environment variables from the Docker image or the job definition.
	//
	// Environment variables cannot start with AWS_BATCH . This naming convention is
	// reserved for variables that Batch sets.
	Environment []KeyValuePair

	// A pointer to the container that you want to override. The container's name
	// provides a unique identifier for the container being used.
	Name *string

	// The type and amount of resources to assign to a container. This overrides the
	// settings in the job definition. The supported resources include GPU , MEMORY ,
	// and VCPU .
	ResourceRequirements []ResourceRequirement

	noSmithyDocumentSerde
}

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

func (v *TaskContainerOverrides) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Command != nil {
		serializeStringList(s, schemas.TaskContainerOverrides_command, v.Command)
	}
	if v.Environment != nil {
		serializeEnvironmentVariables(s, schemas.TaskContainerOverrides_environment, v.Environment)
	}
	if v.Name != nil {
		s.WriteString(schemas.TaskContainerOverrides_name, *v.Name)
	}
	if v.ResourceRequirements != nil {
		serializeResourceRequirements(s, schemas.TaskContainerOverrides_resourceRequirements, v.ResourceRequirements)
	}
}
func (v *TaskContainerOverrides) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.TaskContainerOverrides, func(s *smithy.Schema) error {
		switch s {
		case schemas.TaskContainerOverrides_command:
			return deserializeStringList(d, schemas.TaskContainerOverrides_command, &v.Command)
		case schemas.TaskContainerOverrides_environment:
			return deserializeEnvironmentVariables(d, schemas.TaskContainerOverrides_environment, &v.Environment)
		case schemas.TaskContainerOverrides_name:
			v.Name = new(string)
			return d.ReadString(schemas.TaskContainerOverrides_name, v.Name)
		case schemas.TaskContainerOverrides_resourceRequirements:
			return deserializeResourceRequirements(d, schemas.TaskContainerOverrides_resourceRequirements, &v.ResourceRequirements)
		}
		return nil
	})
}

// Container properties are used for Amazon ECS-based job definitions. These
// properties to describe the container that's launched as part of a job.
type TaskContainerProperties struct {

	// The image used to start a container. This string is passed directly to the
	// Docker daemon. By default, images in the Docker Hub registry are available.
	// Other repositories are specified with either repository-url/image:tag or
	// repository-url/image@digest . Up to 255 letters (uppercase and lowercase),
	// numbers, hyphens, underscores, colons, periods, forward slashes, and number
	// signs are allowed. This parameter maps to Image in the [Create a container] section of the [Docker Remote API] and the
	// IMAGE parameter of the [docker run].
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	//
	// This member is required.
	Image *string

	// The command that's passed to the container. This parameter maps to Cmd in the [Create a container]
	// section of the [Docker Remote API]and the COMMAND parameter to [docker run]. For more information, see [Dockerfile reference: CMD].
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Dockerfile reference: CMD]: https://docs.docker.com/engine/reference/builder/#cmd
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Command []string

	// A list of containers that this container depends on.
	DependsOn []TaskContainerDependency

	// The environment variables to pass to a container. This parameter maps to Env in
	// the [Create a container]section of the [Docker Remote API] and the --env parameter to [docker run].
	//
	// We don't recommend using plaintext environment variables for sensitive
	// information, such as credential data.
	//
	// Environment variables cannot start with AWS_BATCH . This naming convention is
	// reserved for variables that Batch sets.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Environment []KeyValuePair

	// If the essential parameter of a container is marked as true , and that container
	// fails or stops for any reason, all other containers that are part of the task
	// are stopped. If the essential parameter of a container is marked as false, its
	// failure doesn't affect the rest of the containers in a task. If this parameter
	// is omitted, a container is assumed to be essential.
	//
	// All jobs must have at least one essential container. If you have an application
	// that's composed of multiple containers, group containers that are used for a
	// common purpose into components, and separate the different components into
	// multiple task definitions. For more information, see [Application Architecture]in the Amazon Elastic
	// Container Service Developer Guide.
	//
	// [Application Architecture]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html
	Essential *bool

	// The FireLens configuration for the container. This is used to specify and
	// configure a log router for container logs. For more information, see [Custom log]routing in
	// the Amazon Elastic Container Service Developer Guide.
	//
	// [Custom log]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html
	FirelensConfiguration *FirelensConfiguration

	// Linux-specific modifications that are applied to the container, such as Linux
	// kernel capabilities. For more information, see [KernelCapabilities].
	//
	// [KernelCapabilities]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html
	LinuxParameters *LinuxParameters

	// The log configuration specification for the container.
	//
	// This parameter maps to LogConfig in the [Create a container] section of the [Docker Remote API] and the --log-driver
	// option to [docker run].
	//
	// By default, containers use the same logging driver that the Docker daemon uses.
	// However the container can use a different logging driver than the Docker daemon
	// by specifying a log driver with this parameter in the container definition. To
	// use a different logging driver for a container, the log system must be
	// configured properly on the container instance (or on a different log server for
	// remote logging options). For more information about the options for different
	// supported log drivers, see [Configure logging drivers]in the Docker documentation.
	//
	// Amazon ECS currently supports a subset of the logging drivers available to the
	// Docker daemon (shown in the LogConfiguration data type). Additional log drivers
	// may be available in future releases of the Amazon ECS container agent.
	//
	// This parameter requires version 1.18 of the Docker Remote API or greater on
	// your container instance. To check the Docker Remote API version on your
	// container instance, log in to your container instance and run the following
	// command: sudo docker version --format '{{.Server.APIVersion}}'
	//
	// The Amazon ECS container agent running on a container instance must register
	// the logging drivers available on that instance with the
	// ECS_AVAILABLE_LOGGING_DRIVERS environment variable before containers placed on
	// that instance can use these log configuration options. For more information, see
	// [Amazon ECS container agent configuration]in the Amazon Elastic Container Service Developer Guide.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Configure logging drivers]: https://docs.docker.com/engine/admin/logging/overview/
	// [Amazon ECS container agent configuration]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	LogConfiguration *LogConfiguration

	// The mount points for data volumes in your container.
	//
	// This parameter maps to Volumes in the [Create a container] section of the [Docker Remote API] and the --volume option to [docker run].
	//
	// Windows containers can mount whole directories on the same drive as
	// $env:ProgramData . Windows containers can't mount directories on a different
	// drive, and mount point can't be across drives.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	MountPoints []MountPoint

	// The name of a container. The name can be used as a unique identifier to target
	// your dependsOn and Overrides objects.
	Name *string

	// When this parameter is true , the container is given elevated privileges on the
	// host container instance (similar to the root user). This parameter maps to
	// Privileged in the [Create a container] section of the [Docker Remote API] and the --privileged option to [docker run].
	//
	// This parameter is not supported for Windows containers or tasks run on Fargate.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Privileged *bool

	// When this parameter is true, the container is given read-only access to its
	// root file system. This parameter maps to ReadonlyRootfs in the [Create a container] section of the [Docker Remote API]
	// and the --read-only option to [docker run].
	//
	// This parameter is not supported for Windows containers.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	ReadonlyRootFilesystem *bool

	// The private repository authentication credentials to use.
	RepositoryCredentials *RepositoryCredentials

	// The type and amount of a resource to assign to a container. The supported
	// resources include GPU , MEMORY , and VCPU .
	ResourceRequirements []ResourceRequirement

	// The secrets to pass to the container. For more information, see [Specifying Sensitive Data] in the Amazon
	// Elastic Container Service Developer Guide.
	//
	// [Specifying Sensitive Data]: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html
	Secrets []Secret

	// Time duration (in seconds) to wait before giving up on resolving dependencies
	// for a container. The minimum value is 2 seconds and the maximum value for
	// Fargate is 120 seconds.
	StartTimeout *int32

	// Time duration (in seconds) to wait before the container is forcefully killed if
	// it doesn't exit normally on its own. The minimum value is 2 seconds and the
	// maximum value for Fargate is 120 seconds. If the parameter is not specified, the
	// default value of 30 seconds is used. For tasks that use the EC2 launch type, if
	// the stopTimeout parameter isn't specified, the value set for the Amazon ECS
	// container agent configuration variable ECS_CONTAINER_STOP_TIMEOUT is used. If
	// neither the stopTimeout parameter nor the ECS_CONTAINER_STOP_TIMEOUT agent
	// configuration variable are set, then the default value of 30 seconds is used.
	StopTimeout *int32

	// A list of ulimits to set in the container. If a ulimit value is specified in a
	// task definition, it overrides the default values set by Docker. This parameter
	// maps to Ulimits in the [Create a container] section of the [Docker Remote API] and the --ulimit option to [docker run].
	//
	// Amazon ECS tasks hosted on Fargate use the default resource limit values set by
	// the operating system with the exception of the nofile resource limit parameter
	// which Fargate overrides. The nofile resource limit sets a restriction on the
	// number of open files that a container can use. The default nofile soft limit is
	// 1024 and the default hard limit is 65535 .
	//
	// This parameter requires version 1.18 of the Docker Remote API or greater on
	// your container instance. To check the Docker Remote API version on your
	// container instance, log in to your container instance and run the following
	// command: sudo docker version --format '{{.Server.APIVersion}}'
	//
	// This parameter is not supported for Windows containers.
	//
	// [docker run]: https://docs.docker.com/engine/reference/run/#security-configuration
	// [Create a container]: https://docs.docker.com/engine/api/latest/#tag/Container/operation/ContainerCreate
	// [Docker Remote API]: https://docs.docker.com/engine/api/latest/
	Ulimits []Ulimit

	// The user to use inside the container. This parameter maps to User in the Create
	// a container section of the Docker Remote API and the --user option to docker
	// run.
	//
	// When running tasks using the host network mode, don't run containers using the
	// root user (UID 0) . We recommend using a non-root user for better security.
	//
	// You can specify the user using the following formats. If specifying a UID or
	// GID, you must specify it as a positive integer.
	//
	//   - user
	//
	//   - user:group
	//
	//   - uid
	//
	//   - uid:gid
	//
	//   - user:gi
	//
	//   - uid:group
	//
	// This parameter is not supported for Windows containers.
	User *string

	noSmithyDocumentSerde
}

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

func (v *TaskContainerProperties) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Command != nil {
		serializeStringList(s, schemas.TaskContainerProperties_command, v.Command)
	}
	if v.DependsOn != nil {
		serializeTaskContainerDependencyList(s, schemas.TaskContainerProperties_dependsOn, v.DependsOn)
	}
	if v.Environment != nil {
		serializeEnvironmentVariables(s, schemas.TaskContainerProperties_environment, v.Environment)
	}
	if v.Essential != nil {
		s.WriteBool(schemas.TaskContainerProperties_essential, *v.Essential)
	}
	if v.FirelensConfiguration != nil {
		s.WriteStruct(schemas.TaskContainerProperties_firelensConfiguration)
		v.FirelensConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Image != nil {
		s.WriteString(schemas.TaskContainerProperties_image, *v.Image)
	}
	if v.LinuxParameters != nil {
		s.WriteStruct(schemas.TaskContainerProperties_linuxParameters)
		v.LinuxParameters.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.LogConfiguration != nil {
		s.WriteStruct(schemas.TaskContainerProperties_logConfiguration)
		v.LogConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.MountPoints != nil {
		serializeMountPoints(s, schemas.TaskContainerProperties_mountPoints, v.MountPoints)
	}
	if v.Name != nil {
		s.WriteString(schemas.TaskContainerProperties_name, *v.Name)
	}
	if v.Privileged != nil {
		s.WriteBool(schemas.TaskContainerProperties_privileged, *v.Privileged)
	}
	if v.ReadonlyRootFilesystem != nil {
		s.WriteBool(schemas.TaskContainerProperties_readonlyRootFilesystem, *v.ReadonlyRootFilesystem)
	}
	if v.RepositoryCredentials != nil {
		s.WriteStruct(schemas.TaskContainerProperties_repositoryCredentials)
		v.RepositoryCredentials.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.ResourceRequirements != nil {
		serializeResourceRequirements(s, schemas.TaskContainerProperties_resourceRequirements, v.ResourceRequirements)
	}
	if v.Secrets != nil {
		serializeSecretList(s, schemas.TaskContainerProperties_secrets, v.Secrets)
	}
	if v.StartTimeout != nil {
		s.WriteInt32(schemas.TaskContainerProperties_startTimeout, *v.StartTimeout)
	}
	if v.StopTimeout != nil {
		s.WriteInt32(schemas.TaskContainerProperties_stopTimeout, *v.StopTimeout)
	}
	if v.Ulimits != nil {
		serializeUlimits(s, schemas.TaskContainerProperties_ulimits, v.Ulimits)
	}
	if v.User != nil {
		s.WriteString(schemas.TaskContainerProperties_user, *v.User)
	}
}
func (v *TaskContainerProperties) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.TaskContainerProperties, func(s *smithy.Schema) error {
		switch s {
		case schemas.TaskContainerProperties_command:
			return deserializeStringList(d, schemas.TaskContainerProperties_command, &v.Command)
		case schemas.TaskContainerProperties_dependsOn:
			return deserializeTaskContainerDependencyList(d, schemas.TaskContainerProperties_dependsOn, &v.DependsOn)
		case schemas.TaskContainerProperties_environment:
			return deserializeEnvironmentVariables(d, schemas.TaskContainerProperties_environment, &v.Environment)
		case schemas.TaskContainerProperties_essential:
			v.Essential = new(bool)
			return d.ReadBool(schemas.TaskContainerProperties_essential, v.Essential)
		case schemas.TaskContainerProperties_firelensConfiguration:
			v.FirelensConfiguration = &FirelensConfiguration{}
			return v.FirelensConfiguration.Deserialize(d)
		case schemas.TaskContainerProperties_image:
			v.Image = new(string)
			return d.ReadString(schemas.TaskContainerProperties_image, v.Image)
		case schemas.TaskContainerProperties_linuxParameters:
			v.LinuxParameters = &LinuxParameters{}
			return v.LinuxParameters.Deserialize(d)
		case schemas.TaskContainerProperties_logConfiguration:
			v.LogConfiguration = &LogConfiguration{}
			return v.LogConfiguration.Deserialize(d)
		case schemas.TaskContainerProperties_mountPoints:
			return deserializeMountPoints(d, schemas.TaskContainerProperties_mountPoints, &v.MountPoints)
		case schemas.TaskContainerProperties_name:
			v.Name = new(string)
			return d.ReadString(schemas.TaskContainerProperties_name, v.Name)
		case schemas.TaskContainerProperties_privileged:
			v.Privileged = new(bool)
			return d.ReadBool(schemas.TaskContainerProperties_privileged, v.Privileged)
		case schemas.TaskContainerProperties_readonlyRootFilesystem:
			v.ReadonlyRootFilesystem = new(bool)
			return d.ReadBool(schemas.TaskContainerProperties_readonlyRootFilesystem, v.ReadonlyRootFilesystem)
		case schemas.TaskContainerProperties_repositoryCredentials:
			v.RepositoryCredentials = &RepositoryCredentials{}
			return v.RepositoryCredentials.Deserialize(d)
		case schemas.TaskContainerProperties_resourceRequirements:
			return deserializeResourceRequirements(d, schemas.TaskContainerProperties_resourceRequirements, &v.ResourceRequirements)
		case schemas.TaskContainerProperties_secrets:
			return deserializeSecretList(d, schemas.TaskContainerProperties_secrets, &v.Secrets)
		case schemas.TaskContainerProperties_startTimeout:
			v.StartTimeout = new(int32)
			return d.ReadInt32(schemas.TaskContainerProperties_startTimeout, v.StartTimeout)
		case schemas.TaskContainerProperties_stopTimeout:
			v.StopTimeout = new(int32)
			return d.ReadInt32(schemas.TaskContainerProperties_stopTimeout, v.StopTimeout)
		case schemas.TaskContainerProperties_ulimits:
			return deserializeUlimits(d, schemas.TaskContainerProperties_ulimits, &v.Ulimits)
		case schemas.TaskContainerProperties_user:
			v.User = new(string)
			return d.ReadString(schemas.TaskContainerProperties_user, v.User)
		}
		return nil
	})
}

// An object that contains overrides for the task definition of a job.
type TaskPropertiesOverride struct {

	// The overrides for the container definition of a job.
	Containers []TaskContainerOverrides

	noSmithyDocumentSerde
}

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

func (v *TaskPropertiesOverride) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Containers != nil {
		serializeListTaskContainerOverrides(s, schemas.TaskPropertiesOverride_containers, v.Containers)
	}
}
func (v *TaskPropertiesOverride) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.TaskPropertiesOverride, func(s *smithy.Schema) error {
		switch s {
		case schemas.TaskPropertiesOverride_containers:
			return deserializeListTaskContainerOverrides(d, schemas.TaskPropertiesOverride_containers, &v.Containers)
		}
		return nil
	})
}

// An object that contains the details of a job that couldn't be terminated by a
// TerminateJobs operation.
type TerminateJobsErrorDetail struct {

	// An error code that identifies the reason the job couldn't be terminated. Valid
	// values are:
	//
	//   - ValidationException – A job identifier in the request is malformed or isn't
	//   valid.
	//
	//   - ClientException – The request failed because of a client error.
	//
	//   - ThrottlingException – The request was throttled. Retry the request.
	//
	//   - ServerException – An internal error occurred. Retry the request.
	//
	//   - AccessDenied – The caller isn't authorized to perform the action on the
	//   specified job.
	//
	// This member is required.
	Code *string

	// The Batch job ID of the job that couldn't be terminated.
	//
	// This member is required.
	Job *string

	// A message that describes the reason the job couldn't be terminated.
	//
	// This member is required.
	Message *string

	noSmithyDocumentSerde
}

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

func (v *TerminateJobsErrorDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Code != nil {
		s.WriteString(schemas.TerminateJobsErrorDetail_code, *v.Code)
	}
	if v.Job != nil {
		s.WriteString(schemas.TerminateJobsErrorDetail_job, *v.Job)
	}
	if v.Message != nil {
		s.WriteString(schemas.TerminateJobsErrorDetail_message, *v.Message)
	}
}
func (v *TerminateJobsErrorDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.TerminateJobsErrorDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.TerminateJobsErrorDetail_code:
			v.Code = new(string)
			return d.ReadString(schemas.TerminateJobsErrorDetail_code, v.Code)
		case schemas.TerminateJobsErrorDetail_job:
			v.Job = new(string)
			return d.ReadString(schemas.TerminateJobsErrorDetail_job, v.Job)
		case schemas.TerminateJobsErrorDetail_message:
			v.Message = new(string)
			return d.ReadString(schemas.TerminateJobsErrorDetail_message, v.Message)
		}
		return nil
	})
}

// An object that contains the details of a service job that couldn't be
// terminated by a TerminateServiceJobs operation.
type TerminateServiceJobsErrorDetail struct {

	// An error code that identifies the reason the service job couldn't be
	// terminated. Valid values are:
	//
	//   - ValidationException – A service job identifier in the request is malformed
	//   or isn't valid.
	//
	//   - ClientException – The request failed because of a client error.
	//
	//   - ThrottlingException – The request was throttled. Retry the request.
	//
	//   - ServerException – An internal error occurred. Retry the request.
	//
	//   - AccessDenied – The caller isn't authorized to perform the action on the
	//   specified service job.
	//
	// This member is required.
	Code *string

	// The service job ID of the service job that couldn't be terminated.
	//
	// This member is required.
	Job *string

	// A message that describes the reason the service job couldn't be terminated.
	//
	// This member is required.
	Message *string

	noSmithyDocumentSerde
}

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

func (v *TerminateServiceJobsErrorDetail) SerializeMembers(s smithy.ShapeSerializer) {
	if v.Code != nil {
		s.WriteString(schemas.TerminateServiceJobsErrorDetail_code, *v.Code)
	}
	if v.Job != nil {
		s.WriteString(schemas.TerminateServiceJobsErrorDetail_job, *v.Job)
	}
	if v.Message != nil {
		s.WriteString(schemas.TerminateServiceJobsErrorDetail_message, *v.Message)
	}
}
func (v *TerminateServiceJobsErrorDetail) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.TerminateServiceJobsErrorDetail, func(s *smithy.Schema) error {
		switch s {
		case schemas.TerminateServiceJobsErrorDetail_code:
			v.Code = new(string)
			return d.ReadString(schemas.TerminateServiceJobsErrorDetail_code, v.Code)
		case schemas.TerminateServiceJobsErrorDetail_job:
			v.Job = new(string)
			return d.ReadString(schemas.TerminateServiceJobsErrorDetail_job, v.Job)
		case schemas.TerminateServiceJobsErrorDetail_message:
			v.Message = new(string)
			return d.ReadString(schemas.TerminateServiceJobsErrorDetail_message, v.Message)
		}
		return nil
	})
}

// The container path, mount options, and size of the tmpfs mount.
//
// This object isn't applicable to jobs that are running on Fargate resources.
type Tmpfs struct {

	// The absolute file path in the container where the tmpfs volume is mounted.
	//
	// This member is required.
	ContainerPath *string

	// The size (in MiB) of the tmpfs volume.
	//
	// This member is required.
	Size *int32

	// The list of tmpfs volume mount options.
	//
	// Valid values: " defaults " | " ro " | " rw " | " suid " | " nosuid " | " dev " |
	// " nodev " | " exec " | " noexec " | " sync " | " async " | " dirsync " | "
	// remount " | " mand " | " nomand " | " atime " | " noatime " | " diratime " | "
	// nodiratime " | " bind " | " rbind" | "unbindable" | "runbindable" | "private" |
	// "rprivate" | "shared" | "rshared" | "slave" | "rslave" | "relatime " | "
	// norelatime " | " strictatime " | " nostrictatime " | " mode " | " uid " | " gid
	// " | " nr_inodes " | " nr_blocks " | " mpol "
	MountOptions []string

	noSmithyDocumentSerde
}

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

func (v *Tmpfs) SerializeMembers(s smithy.ShapeSerializer) {
	if v.ContainerPath != nil {
		s.WriteString(schemas.Tmpfs_containerPath, *v.ContainerPath)
	}
	if v.MountOptions != nil {
		serializeStringList(s, schemas.Tmpfs_mountOptions, v.MountOptions)
	}
	if v.Size != nil {
		s.WriteInt32(schemas.Tmpfs_size, *v.Size)
	}
}
func (v *Tmpfs) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Tmpfs, func(s *smithy.Schema) error {
		switch s {
		case schemas.Tmpfs_containerPath:
			v.ContainerPath = new(string)
			return d.ReadString(schemas.Tmpfs_containerPath, v.ContainerPath)
		case schemas.Tmpfs_mountOptions:
			return deserializeStringList(d, schemas.Tmpfs_mountOptions, &v.MountOptions)
		case schemas.Tmpfs_size:
			v.Size = new(int32)
			return d.ReadInt32(schemas.Tmpfs_size, v.Size)
		}
		return nil
	})
}

// The ulimit settings to pass to the container. For more information, see [Ulimit].
//
// This object isn't applicable to jobs that are running on Fargate resources.
//
// [Ulimit]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Ulimit.html
type Ulimit struct {

	// The hard limit for the ulimit type.
	//
	// This member is required.
	HardLimit *int32

	// The type of the ulimit . Valid values are: core | cpu | data | fsize | locks |
	// memlock | msgqueue | nice | nofile | nproc | rss | rtprio | rttime | sigpending
	// | stack .
	//
	// This member is required.
	Name *string

	// The soft limit for the ulimit type.
	//
	// This member is required.
	SoftLimit *int32

	noSmithyDocumentSerde
}

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

func (v *Ulimit) SerializeMembers(s smithy.ShapeSerializer) {
	if v.HardLimit != nil {
		s.WriteInt32(schemas.Ulimit_hardLimit, *v.HardLimit)
	}
	if v.Name != nil {
		s.WriteString(schemas.Ulimit_name, *v.Name)
	}
	if v.SoftLimit != nil {
		s.WriteInt32(schemas.Ulimit_softLimit, *v.SoftLimit)
	}
}
func (v *Ulimit) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Ulimit, func(s *smithy.Schema) error {
		switch s {
		case schemas.Ulimit_hardLimit:
			v.HardLimit = new(int32)
			return d.ReadInt32(schemas.Ulimit_hardLimit, v.HardLimit)
		case schemas.Ulimit_name:
			v.Name = new(string)
			return d.ReadString(schemas.Ulimit_name, v.Name)
		case schemas.Ulimit_softLimit:
			v.SoftLimit = new(int32)
			return d.ReadInt32(schemas.Ulimit_softLimit, v.SoftLimit)
		}
		return nil
	})
}

// The configuration for updating an Amazon ECS Managed Instances capacity
// provider. Used in UpdateComputeEnvironment requests. The capacityOptionType and
// fipsEnabled fields cannot be changed on update.
type UpdateManagedInstancesProviderConfiguration struct {

	// The updated infrastructure optimization configuration.
	InfrastructureOptimization *InfrastructureOptimization

	// The updated Amazon Resource Name (ARN) of the IAM role that Amazon ECS assumes
	// to manage Amazon EC2 instances on your behalf.
	InfrastructureRoleArn *string

	// The updated instance launch configuration for the Amazon ECS Managed Instances
	// capacity provider.
	InstanceLaunchTemplate *InstanceLaunchTemplateUpdate

	// Specifies whether tags on the capacity provider are propagated to the Amazon
	// EC2 instances it launches. Valid values:
	//
	//   - CAPACITY_PROVIDER — Propagates tags to instances.
	//
	//   - NONE — Does not propagate tags to instances.
	PropagateTags *string

	noSmithyDocumentSerde
}

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

func (v *UpdateManagedInstancesProviderConfiguration) SerializeMembers(s smithy.ShapeSerializer) {
	if v.InfrastructureOptimization != nil {
		s.WriteStruct(schemas.UpdateManagedInstancesProviderConfiguration_infrastructureOptimization)
		v.InfrastructureOptimization.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.InfrastructureRoleArn != nil {
		s.WriteString(schemas.UpdateManagedInstancesProviderConfiguration_infrastructureRoleArn, *v.InfrastructureRoleArn)
	}
	if v.InstanceLaunchTemplate != nil {
		s.WriteStruct(schemas.UpdateManagedInstancesProviderConfiguration_instanceLaunchTemplate)
		v.InstanceLaunchTemplate.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.PropagateTags != nil {
		s.WriteString(schemas.UpdateManagedInstancesProviderConfiguration_propagateTags, *v.PropagateTags)
	}
}
func (v *UpdateManagedInstancesProviderConfiguration) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.UpdateManagedInstancesProviderConfiguration, func(s *smithy.Schema) error {
		switch s {
		case schemas.UpdateManagedInstancesProviderConfiguration_infrastructureOptimization:
			v.InfrastructureOptimization = &InfrastructureOptimization{}
			return v.InfrastructureOptimization.Deserialize(d)
		case schemas.UpdateManagedInstancesProviderConfiguration_infrastructureRoleArn:
			v.InfrastructureRoleArn = new(string)
			return d.ReadString(schemas.UpdateManagedInstancesProviderConfiguration_infrastructureRoleArn, v.InfrastructureRoleArn)
		case schemas.UpdateManagedInstancesProviderConfiguration_instanceLaunchTemplate:
			v.InstanceLaunchTemplate = &InstanceLaunchTemplateUpdate{}
			return v.InstanceLaunchTemplate.Deserialize(d)
		case schemas.UpdateManagedInstancesProviderConfiguration_propagateTags:
			v.PropagateTags = new(string)
			return d.ReadString(schemas.UpdateManagedInstancesProviderConfiguration_propagateTags, v.PropagateTags)
		}
		return nil
	})
}

// Specifies the infrastructure update policy for the Amazon EC2 compute
// environment. For more information about infrastructure updates, see [Updating compute environments]in the
// Batch User Guide.
//
// The updatePolicy property applies only to Amazon EC2 managed compute
// environments. Batch doesn't support updatePolicy for Fargate compute
// environments. If you specify it for a Fargate compute environment, Batch ignores
// it.
//
// [Updating compute environments]: https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
type UpdatePolicy struct {

	// Specifies the job timeout (in minutes) when the compute environment
	// infrastructure is updated. The default value is 30. The maximum value is 7200.
	//
	// Increasing jobExecutionTimeoutMinutes during infrastructure updates delays the
	// replacement of instances with new instances that include updates such as
	// security patches, but provides more time for jobs to execute. Consider the
	// security implications of this tradeoff when setting timeout values.
	JobExecutionTimeoutMinutes *int64

	// Specifies whether jobs are automatically terminated when the compute
	// environment infrastructure is updated. The default value is false .
	TerminateJobsOnUpdate *bool

	noSmithyDocumentSerde
}

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

func (v *UpdatePolicy) SerializeMembers(s smithy.ShapeSerializer) {
	if v.JobExecutionTimeoutMinutes != nil {
		s.WriteInt64(schemas.UpdatePolicy_jobExecutionTimeoutMinutes, *v.JobExecutionTimeoutMinutes)
	}
	if v.TerminateJobsOnUpdate != nil {
		s.WriteBool(schemas.UpdatePolicy_terminateJobsOnUpdate, *v.TerminateJobsOnUpdate)
	}
}
func (v *UpdatePolicy) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.UpdatePolicy, func(s *smithy.Schema) error {
		switch s {
		case schemas.UpdatePolicy_jobExecutionTimeoutMinutes:
			v.JobExecutionTimeoutMinutes = new(int64)
			return d.ReadInt64(schemas.UpdatePolicy_jobExecutionTimeoutMinutes, v.JobExecutionTimeoutMinutes)
		case schemas.UpdatePolicy_terminateJobsOnUpdate:
			v.TerminateJobsOnUpdate = new(bool)
			return d.ReadBool(schemas.UpdatePolicy_terminateJobsOnUpdate, v.TerminateJobsOnUpdate)
		}
		return nil
	})
}

// A data volume that's used in a job's container properties.
type Volume struct {

	// This parameter is specified when you're using an Amazon Elastic File System
	// file system for job storage. Jobs that are running on Fargate resources must
	// specify a platformVersion of at least 1.4.0 .
	EfsVolumeConfiguration *EFSVolumeConfiguration

	// The contents of the host parameter determine whether your data volume persists
	// on the host container instance and where it's stored. If the host parameter is
	// empty, then the Docker daemon assigns a host path for your data volume. However,
	// the data isn't guaranteed to persist after the containers that are associated
	// with it stop running.
	//
	// This parameter isn't applicable to jobs that are running on Fargate resources
	// and shouldn't be provided.
	Host *Host

	// The name of the volume. It can be up to 255 characters long. It can contain
	// uppercase and lowercase letters, numbers, hyphens (-), and underscores (_). This
	// name is referenced in the sourceVolume parameter of container definition
	// mountPoints .
	Name *string

	// This parameter is specified when you're using an S3Files file system for job
	// storage.
	S3filesVolumeConfiguration *S3FilesVolumeConfiguration

	noSmithyDocumentSerde
}

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

func (v *Volume) SerializeMembers(s smithy.ShapeSerializer) {
	if v.EfsVolumeConfiguration != nil {
		s.WriteStruct(schemas.Volume_efsVolumeConfiguration)
		v.EfsVolumeConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Host != nil {
		s.WriteStruct(schemas.Volume_host)
		v.Host.SerializeMembers(s)
		s.CloseStruct()
	}
	if v.Name != nil {
		s.WriteString(schemas.Volume_name, *v.Name)
	}
	if v.S3filesVolumeConfiguration != nil {
		s.WriteStruct(schemas.Volume_s3filesVolumeConfiguration)
		v.S3filesVolumeConfiguration.SerializeMembers(s)
		s.CloseStruct()
	}
}
func (v *Volume) Deserialize(d smithy.ShapeDeserializer) error {
	return smithy.ReadStruct(d, schemas.Volume, func(s *smithy.Schema) error {
		switch s {
		case schemas.Volume_efsVolumeConfiguration:
			v.EfsVolumeConfiguration = &EFSVolumeConfiguration{}
			return v.EfsVolumeConfiguration.Deserialize(d)
		case schemas.Volume_host:
			v.Host = &Host{}
			return v.Host.Deserialize(d)
		case schemas.Volume_name:
			v.Name = new(string)
			return d.ReadString(schemas.Volume_name, v.Name)
		case schemas.Volume_s3filesVolumeConfiguration:
			v.S3filesVolumeConfiguration = &S3FilesVolumeConfiguration{}
			return v.S3filesVolumeConfiguration.Deserialize(d)
		}
		return nil
	})
}

type noSmithyDocumentSerde = smithydocument.NoSerde