types

type AccessDeniedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type AgentUpdateStatus string

type ApplicationProtocol string

type AssignPublicIp string

type Attachment struct {

	// Details of the attachment. For elastic network interfaces, this includes the
	// network interface ID, the MAC address, the subnet ID, and the private IPv4
	// address. For Service Connect services, this includes portName , clientAliases ,
	// discoveryName , and ingressPortOverride . For Elastic Block Storage, this
	// includes roleArn , deleteOnTermination , volumeName , volumeId , and
	// statusReason (only when the attachment fails to create or attach).
	Details []KeyValuePair

	// The unique identifier for the attachment.
	Id *string

	// The status of the attachment. Valid values are PRECREATED , CREATED , ATTACHING
	// , ATTACHED , DETACHING , DETACHED , DELETED , and FAILED .
	Status *string

	// The type of the attachment, such as ElasticNetworkInterface , Service Connect ,
	// and AmazonElasticBlockStorage .
	Type *string
	// contains filtered or unexported fields
}

type AttachmentStateChange struct {

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

	// The status of the attachment.
	//
	// This member is required.
	Status *string
	// contains filtered or unexported fields
}

type Attribute struct {

	// The name of the attribute. The name must contain between 1 and 128 characters.
	// The name may contain letters (uppercase and lowercase), numbers, hyphens (-),
	// underscores (_), forward slashes (/), back slashes (\), or periods (.).
	//
	// This member is required.
	Name *string

	// The ID of the target. You can specify the short form ID for a resource or the
	// full Amazon Resource Name (ARN).
	TargetId *string

	// The type of the target to attach the attribute with. This parameter is required
	// if you use the short form ID for a resource instead of the full ARN.
	TargetType TargetType

	// The value of the attribute. The value must contain between 1 and 128
	// characters. It can contain letters (uppercase and lowercase), numbers, hyphens
	// (-), underscores (_), periods (.), at signs (@), forward slashes (/), back
	// slashes (\), colons (:), or spaces. The value can't start or end with a space.
	Value *string
	// contains filtered or unexported fields
}

type AttributeLimitExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type AutoScalingGroupProvider struct {

	// The Amazon Resource Name (ARN) that identifies the Auto Scaling group, or the
	// Auto Scaling group name.
	//
	// This member is required.
	AutoScalingGroupArn *string

	// The managed draining option for the Auto Scaling group capacity provider. When
	// you enable this, Amazon ECS manages and gracefully drains the EC2 container
	// instances that are in the Auto Scaling group capacity provider.
	ManagedDraining ManagedDraining

	// The managed scaling settings for the Auto Scaling group capacity provider.
	ManagedScaling *ManagedScaling

	// The managed termination protection setting to use for the Auto Scaling group
	// capacity provider. This determines whether the Auto Scaling group has managed
	// termination protection. The default is off. When using managed termination
	// protection, managed scaling must also be used otherwise managed termination
	// protection doesn't work. When managed termination protection is on, Amazon ECS
	// prevents the Amazon EC2 instances in an Auto Scaling group that contain tasks
	// from being terminated during a scale-in action. The Auto Scaling group and each
	// instance in the Auto Scaling group must have instance protection from scale-in
	// actions on as well. For more information, see Instance Protection (https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection)
	// in the Auto Scaling User Guide. When managed termination protection is off, your
	// Amazon EC2 instances aren't protected from termination when the Auto Scaling
	// group scales in.
	ManagedTerminationProtection ManagedTerminationProtection
	// contains filtered or unexported fields
}

type AutoScalingGroupProviderUpdate struct {

	// The managed draining option for the Auto Scaling group capacity provider. When
	// you enable this, Amazon ECS manages and gracefully drains the EC2 container
	// instances that are in the Auto Scaling group capacity provider.
	ManagedDraining ManagedDraining

	// The managed scaling settings for the Auto Scaling group capacity provider.
	ManagedScaling *ManagedScaling

	// The managed termination protection setting to use for the Auto Scaling group
	// capacity provider. This determines whether the Auto Scaling group has managed
	// termination protection. When using managed termination protection, managed
	// scaling must also be used otherwise managed termination protection doesn't work.
	// When managed termination protection is on, Amazon ECS prevents the Amazon EC2
	// instances in an Auto Scaling group that contain tasks from being terminated
	// during a scale-in action. The Auto Scaling group and each instance in the Auto
	// Scaling group must have instance protection from scale-in actions on. For more
	// information, see Instance Protection (https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection)
	// in the Auto Scaling User Guide. When managed termination protection is off, your
	// Amazon EC2 instances aren't protected from termination when the Auto Scaling
	// group scales in.
	ManagedTerminationProtection ManagedTerminationProtection
	// contains filtered or unexported fields
}

type AwsVpcConfiguration struct {

	// The IDs of the subnets associated with the task or service. There's a limit of
	// 16 subnets that can be specified per AwsVpcConfiguration . All specified subnets
	// must be from the same VPC.
	//
	// This member is required.
	Subnets []string

	// Whether the task's elastic network interface receives a public IP address. The
	// default value is DISABLED .
	AssignPublicIp AssignPublicIp

	// The IDs of the security groups associated with the task or service. If you
	// don't specify a security group, the default security group for the VPC is used.
	// There's a limit of 5 security groups that can be specified per
	// AwsVpcConfiguration . All specified security groups must be from the same VPC.
	SecurityGroups []string
	// contains filtered or unexported fields
}

type BlockedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type CPUArchitecture string

type CapacityProvider struct {

	// The Auto Scaling group settings for the capacity provider.
	AutoScalingGroupProvider *AutoScalingGroupProvider

	// The Amazon Resource Name (ARN) that identifies the capacity provider.
	CapacityProviderArn *string

	// The name of the capacity provider.
	Name *string

	// The current status of the capacity provider. Only capacity providers in an
	// ACTIVE state can be used in a cluster. When a capacity provider is successfully
	// deleted, it has an INACTIVE status.
	Status CapacityProviderStatus

	// The metadata that you apply to the capacity provider to help you categorize and
	// organize it. Each tag consists of a key and an optional value. You define both.
	// The following basic restrictions apply to tags:
	//   - Maximum number of tags per resource - 50
	//   - For each resource, each tag key must be unique, and each tag key can have
	//   only one value.
	//   - Maximum key length - 128 Unicode characters in UTF-8
	//   - Maximum value length - 256 Unicode characters in UTF-8
	//   - If your tagging schema is used across multiple services and resources,
	//   remember that other services may have restrictions on allowed characters.
	//   Generally allowed characters are: letters, numbers, and spaces representable in
	//   UTF-8, and the following characters: + - = . _ : / @.
	//   - Tag keys and values are case-sensitive.
	//   - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
	//   prefix for either keys or values as it is reserved for Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	Tags []Tag

	// The update status of the capacity provider. The following are the possible
	// states that is returned. DELETE_IN_PROGRESS The capacity provider is in the
	// process of being deleted. DELETE_COMPLETE The capacity provider was successfully
	// deleted and has an INACTIVE status. DELETE_FAILED The capacity provider can't
	// be deleted. The update status reason provides further details about why the
	// delete failed.
	UpdateStatus CapacityProviderUpdateStatus

	// The update status reason. This provides further details about the update status
	// for the capacity provider.
	UpdateStatusReason *string
	// contains filtered or unexported fields
}

type CapacityProviderField string

type CapacityProviderStatus string

type CapacityProviderStrategyItem struct {

	// The short name of the capacity provider.
	//
	// This member is required.
	CapacityProvider *string

	// The base value designates how many tasks, at a minimum, to run on the specified
	// capacity provider. Only one capacity provider in a capacity provider strategy
	// can have a base defined. If no value is specified, the default value of 0 is
	// used.
	Base int32

	// The weight value designates the relative percentage of the total number of
	// tasks launched that should use the specified capacity provider. The weight
	// value is taken into consideration after the base value, if defined, is
	// satisfied. If no weight value is specified, the default value of 0 is used.
	// When multiple capacity providers are specified within a capacity provider
	// strategy, at least one of the capacity providers must have a weight value
	// greater than zero and any capacity providers with a weight of 0 can't be used
	// to place tasks. If you specify multiple capacity providers in a strategy that
	// all have a weight of 0 , any RunTask or CreateService actions using the
	// capacity provider strategy will fail. An example scenario for using weights is
	// defining a strategy that contains two capacity providers and both have a weight
	// of 1 , then when the base is satisfied, the tasks will be split evenly across
	// the two capacity providers. Using that same logic, if you specify a weight of 1
	// for capacityProviderA and a weight of 4 for capacityProviderB, then for every
	// one task that's run using capacityProviderA, four tasks would use
	// capacityProviderB.
	Weight int32
	// contains filtered or unexported fields
}

type CapacityProviderUpdateStatus string

type ClientException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type Cluster struct {

	// The number of services that are running on the cluster in an ACTIVE state. You
	// can view these services with ListServices .
	ActiveServicesCount int32

	// The resources attached to a cluster. When using a capacity provider with a
	// cluster, the capacity provider and associated resources are returned as cluster
	// attachments.
	Attachments []Attachment

	// The status of the capacity providers associated with the cluster. The following
	// are the states that are returned. UPDATE_IN_PROGRESS The available capacity
	// providers for the cluster are updating. UPDATE_COMPLETE The capacity providers
	// have successfully updated. UPDATE_FAILED The capacity provider updates failed.
	AttachmentsStatus *string

	// The capacity providers associated with the cluster.
	CapacityProviders []string

	// The Amazon Resource Name (ARN) that identifies the cluster. For more
	// information about the ARN format, see Amazon Resource Name (ARN) (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#ecs-resource-ids)
	// in the Amazon ECS Developer Guide.
	ClusterArn *string

	// A user-generated string that you use to identify your cluster.
	ClusterName *string

	// The execute command configuration for the cluster.
	Configuration *ClusterConfiguration

	// The default capacity provider strategy for the cluster. When services or tasks
	// are run in the cluster with no launch type or capacity provider strategy
	// specified, the default capacity provider strategy is used.
	DefaultCapacityProviderStrategy []CapacityProviderStrategyItem

	// The number of tasks in the cluster that are in the PENDING state.
	PendingTasksCount int32

	// The number of container instances registered into the cluster. This includes
	// container instances in both ACTIVE and DRAINING status.
	RegisteredContainerInstancesCount int32

	// The number of tasks in the cluster that are in the RUNNING state.
	RunningTasksCount int32

	// Use this parameter to set a default Service Connect namespace. After you set a
	// default Service Connect namespace, any new services with Service Connect turned
	// on that are created in the cluster are added as client services in the
	// namespace. This setting only applies to new services that set the enabled
	// parameter to true in the ServiceConnectConfiguration . You can set the namespace
	// of each service individually in the ServiceConnectConfiguration to override
	// this default parameter. Tasks that run in a namespace can use short names to
	// connect to services in the namespace. Tasks can connect to services across all
	// of the clusters in the namespace. Tasks connect through a managed proxy
	// container that collects logs and metrics for increased visibility. Only the
	// tasks that Amazon ECS services create are supported with Service Connect. For
	// more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectDefaults *ClusterServiceConnectDefaults

	// The settings for the cluster. This parameter indicates whether CloudWatch
	// Container Insights is on or off for a cluster.
	Settings []ClusterSetting

	// Additional information about your clusters that are separated by launch type.
	// They include the following:
	//   - runningEC2TasksCount
	//   - RunningFargateTasksCount
	//   - pendingEC2TasksCount
	//   - pendingFargateTasksCount
	//   - activeEC2ServiceCount
	//   - activeFargateServiceCount
	//   - drainingEC2ServiceCount
	//   - drainingFargateServiceCount
	Statistics []KeyValuePair

	// The status of the cluster. The following are the possible states that are
	// returned. ACTIVE The cluster is ready to accept tasks and if applicable you can
	// register container instances with the cluster. PROVISIONING The cluster has
	// capacity providers that are associated with it and the resources needed for the
	// capacity provider are being created. DEPROVISIONING The cluster has capacity
	// providers that are associated with it and the resources needed for the capacity
	// provider are being deleted. FAILED The cluster has capacity providers that are
	// associated with it and the resources needed for the capacity provider have
	// failed to create. INACTIVE The cluster has been deleted. Clusters with an
	// INACTIVE status may remain discoverable in your account for a period of time.
	// However, this behavior is subject to change in the future. We don't recommend
	// that you rely on INACTIVE clusters persisting.
	Status *string

	// The metadata that you apply to the cluster to help you categorize and organize
	// them. Each tag consists of a key and an optional value. You define both. The
	// following basic restrictions apply to tags:
	//   - Maximum number of tags per resource - 50
	//   - For each resource, each tag key must be unique, and each tag key can have
	//   only one value.
	//   - Maximum key length - 128 Unicode characters in UTF-8
	//   - Maximum value length - 256 Unicode characters in UTF-8
	//   - If your tagging schema is used across multiple services and resources,
	//   remember that other services may have restrictions on allowed characters.
	//   Generally allowed characters are: letters, numbers, and spaces representable in
	//   UTF-8, and the following characters: + - = . _ : / @.
	//   - Tag keys and values are case-sensitive.
	//   - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
	//   prefix for either keys or values as it is reserved for Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	Tags []Tag
	// contains filtered or unexported fields
}

type ClusterConfiguration struct {

	// The details of the execute command configuration.
	ExecuteCommandConfiguration *ExecuteCommandConfiguration
	// contains filtered or unexported fields
}

type ClusterContainsContainerInstancesException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ClusterContainsServicesException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ClusterContainsTasksException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ClusterField string

type ClusterNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ClusterServiceConnectDefaults struct {

	// The namespace name or full Amazon Resource Name (ARN) of the Cloud Map
	// namespace. When you create a service and don't specify a Service Connect
	// configuration, this namespace is used.
	Namespace *string
	// contains filtered or unexported fields
}

type ClusterServiceConnectDefaultsRequest struct {

	// The namespace name or full Amazon Resource Name (ARN) of the Cloud Map
	// namespace that's used when you create a service and don't specify a Service
	// Connect configuration. The namespace name can include up to 1024 characters. The
	// name is case-sensitive. The name can't include hyphens (-), tilde (~), greater
	// than (>), less than (<), or slash (/). If you enter an existing namespace name
	// or ARN, then that namespace will be used. Any namespace type is supported. The
	// namespace must be in this account and this Amazon Web Services Region. If you
	// enter a new name, a Cloud Map namespace will be created. Amazon ECS creates a
	// Cloud Map namespace with the "API calls" method of instance discovery only. This
	// instance discovery method is the "HTTP" namespace type in the Command Line
	// Interface. Other types of instance discovery aren't used by Service Connect. If
	// you update the cluster with an empty string "" for the namespace name, the
	// cluster configuration for Service Connect is removed. Note that the namespace
	// will remain in Cloud Map and must be deleted separately. For more information
	// about Cloud Map, see Working with Services (https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html)
	// in the Cloud Map Developer Guide.
	//
	// This member is required.
	Namespace *string
	// contains filtered or unexported fields
}

type ClusterSetting struct {

	// The name of the cluster setting. The value is containerInsights .
	Name ClusterSettingName

	// The value to set for the cluster setting. The supported values are enabled and
	// disabled . If you set name to containerInsights and value to enabled ,
	// CloudWatch Container Insights will be on for the cluster, otherwise it will be
	// off unless the containerInsights account setting is turned on. If a cluster
	// value is specified, it will override the containerInsights value set with
	// PutAccountSetting (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSetting.html)
	// or PutAccountSettingDefault (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSettingDefault.html)
	// .
	Value *string
	// contains filtered or unexported fields
}

type ClusterSettingName string

type Compatibility string

type ConflictException struct {
	Message *string

	ErrorCodeOverride *string

	ResourceIds []string
	// contains filtered or unexported fields
}

type Connectivity string

type Container struct {

	// The Amazon Resource Name (ARN) of the container.
	ContainerArn *string

	// The number of CPU units set for the container. The value is 0 if no value was
	// specified in the container definition when the task definition was registered.
	Cpu *string

	// The exit code returned from the container.
	ExitCode *int32

	// The IDs of each GPU assigned to the container.
	GpuIds []string

	// The health status of the container. If health checks aren't configured for this
	// container in its task definition, then it reports the health status as UNKNOWN .
	HealthStatus HealthStatus

	// The image used for the container.
	Image *string

	// The container image manifest digest.
	ImageDigest *string

	// The last known status of the container.
	LastStatus *string

	// The details of any Amazon ECS managed agents associated with the container.
	ManagedAgents []ManagedAgent

	// The hard limit (in MiB) of memory set for the container.
	Memory *string

	// The soft limit (in MiB) of memory set for the container.
	MemoryReservation *string

	// The name of the container.
	Name *string

	// The network bindings associated with the container.
	NetworkBindings []NetworkBinding

	// The network interfaces associated with the container.
	NetworkInterfaces []NetworkInterface

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

	// The ID of the Docker container.
	RuntimeId *string

	// The ARN of the task.
	TaskArn *string
	// contains filtered or unexported fields
}

type ContainerCondition string

type ContainerDefinition struct {

	// The command that's passed to the container. This parameter maps to Cmd in the
	// Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the COMMAND parameter to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . For more information, see
	// https://docs.docker.com/engine/reference/builder/#cmd (https://docs.docker.com/engine/reference/builder/#cmd)
	// . If there are multiple arguments, each argument is a separated string in the
	// array.
	Command []string

	// The number of cpu units reserved for the container. This parameter maps to
	// CpuShares in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --cpu-shares option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . This field is optional for tasks using the Fargate launch type, and the only
	// requirement is that the total amount of CPU reserved for all containers within a
	// task be lower than the task-level cpu value. You can determine the number of
	// CPU units that are available per EC2 instance type by multiplying the vCPUs
	// listed for that instance type on the Amazon EC2 Instances (http://aws.amazon.com/ec2/instance-types/)
	// detail page by 1,024. Linux containers share unallocated CPU units with other
	// containers on the container instance with the same ratio as their allocated
	// amount. For example, if you run a single-container task on a single-core
	// instance type with 512 CPU units specified for that container, and that's the
	// only task running on the container instance, that container could use the full
	// 1,024 CPU unit share at any given time. However, if you launched another copy of
	// the same task on that container instance, each task is guaranteed a minimum of
	// 512 CPU units when needed. Moreover, each container could float to higher CPU
	// usage if the other container was not using it. If both tasks were 100% active
	// all of the time, they would be limited to 512 CPU units. On Linux container
	// instances, the Docker daemon on the container instance uses the CPU value to
	// calculate the relative CPU share ratios for running containers. For more
	// information, see CPU share constraint (https://docs.docker.com/engine/reference/run/#cpu-share-constraint)
	// in the Docker documentation. The minimum valid CPU share value that the Linux
	// kernel allows is 2. However, the CPU parameter isn't required, and you can use
	// CPU values below 2 in your container definitions. For CPU values below 2
	// (including null), the behavior varies based on your Amazon ECS container agent
	// version:
	//   - Agent versions less than or equal to 1.1.0: Null and zero CPU values are
	//   passed to Docker as 0, which Docker then converts to 1,024 CPU shares. CPU
	//   values of 1 are passed to Docker as 1, which the Linux kernel converts to two
	//   CPU shares.
	//   - Agent versions greater than or equal to 1.2.0: Null, zero, and CPU values
	//   of 1 are passed to Docker as 2.
	// On Windows container instances, the CPU limit is enforced as an absolute limit,
	// or a quota. Windows containers only have access to the specified amount of CPU
	// that's described in the task definition. A null or zero CPU value is passed to
	// Docker as 0 , which Windows interprets as 1% of one CPU.
	Cpu int32

	// A list of ARNs in SSM or Amazon S3 to a credential spec ( CredSpec ) file that
	// configures the container for Active Directory authentication. We recommend that
	// you use this parameter instead of the dockerSecurityOptions . The maximum number
	// of ARNs is 1. There are two formats for each ARN. credentialspecdomainless:MyARN
	// You use credentialspecdomainless:MyARN to provide a CredSpec with an additional
	// section for a secret in Secrets Manager. You provide the login credentials to
	// the domain in the secret. Each task that runs on any container instance can join
	// different domains. You can use this format without joining the container
	// instance to a domain. credentialspec:MyARN You use credentialspec:MyARN to
	// provide a CredSpec for a single domain. You must join the container instance to
	// the domain before you start any tasks that use this task definition. In both
	// formats, replace MyARN with the ARN in SSM or Amazon S3. If you provide a
	// credentialspecdomainless:MyARN , the credspec must provide a ARN in Secrets
	// Manager for a secret containing the username, password, and the domain to
	// connect to. For better security, the instance isn't joined to the domain for
	// domainless authentication. Other applications on the instance can't use the
	// domainless credentials. You can use this parameter to run tasks on the same
	// instance, even it the tasks need to join different domains. For more
	// information, see Using gMSAs for Windows Containers (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html)
	// and Using gMSAs for Linux Containers (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html)
	// .
	CredentialSpecs []string

	// The dependencies defined for container startup and shutdown. A container can
	// contain multiple dependencies on other containers in a task definition. When a
	// dependency is defined for container startup, for container shutdown it is
	// reversed. For tasks using the EC2 launch type, the container instances require
	// at least version 1.26.0 of the container agent to turn on container
	// dependencies. However, we recommend using the latest container agent version.
	// For information about checking your agent version and updating to the latest
	// version, see Updating the Amazon ECS Container Agent (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html)
	// in the Amazon Elastic Container Service Developer Guide. If you're using an
	// Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of
	// the ecs-init package. If your container instances are launched from version
	// 20190301 or later, then they contain the required versions of the container
	// agent and ecs-init . For more information, see Amazon ECS-optimized Linux AMI (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)
	// in the Amazon Elastic Container Service Developer Guide. For tasks using the
	// Fargate launch type, the task or service requires the following platforms:
	//   - Linux platform version 1.3.0 or later.
	//   - Windows platform version 1.0.0 or later.
	DependsOn []ContainerDependency

	// When this parameter is true, networking is off within the container. This
	// parameter maps to NetworkDisabled in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) .
	// This parameter is not supported for Windows containers.
	DisableNetworking *bool

	// A list of DNS search domains that are presented to the container. This
	// parameter maps to DnsSearch in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --dns-search option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . This parameter is not supported for Windows containers.
	DnsSearchDomains []string

	// A list of DNS servers that are presented to the container. This parameter maps
	// to Dns in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --dns option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . This parameter is not supported for Windows containers.
	DnsServers []string

	// A key/value map of labels to add to the container. This parameter maps to Labels
	// in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --label option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . 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}}'
	DockerLabels map[string]string

	// A list of strings to provide custom configuration for multiple security
	// systems. For more information about valid values, see Docker Run Security
	// Configuration (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . This field isn't valid for containers in tasks using the Fargate launch type.
	// For Linux tasks on EC2, this parameter can be used to reference custom labels
	// for SELinux and AppArmor multi-level security systems. For any tasks on EC2,
	// this parameter can be used to reference a credential spec file that configures a
	// container for Active Directory authentication. For more information, see Using
	// gMSAs for Windows Containers (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html)
	// and Using gMSAs for Linux Containers (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html)
	// in the Amazon Elastic Container Service Developer Guide. This parameter maps to
	// SecurityOpt in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --security-opt option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . The Amazon ECS container agent running on a container instance must register
	// with the ECS_SELINUX_CAPABLE=true or ECS_APPARMOR_CAPABLE=true environment
	// variables before containers placed on that instance can use these security
	// options. For more information, see Amazon ECS Container Agent Configuration (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
	// in the Amazon Elastic Container Service Developer Guide. For more information
	// about valid values, see Docker Run Security Configuration (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . Valid values: "no-new-privileges" | "apparmor:PROFILE" | "label:value" |
	// "credentialspec:CredentialSpecFilePath"
	DockerSecurityOptions []string

	// Early versions of the Amazon ECS container agent don't properly handle
	// entryPoint parameters. If you have problems using entryPoint , update your
	// container agent or enter your commands and arguments as command array items
	// instead. The entry point that's passed to the container. This parameter maps to
	// Entrypoint in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --entrypoint option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . For more information, see
	// https://docs.docker.com/engine/reference/builder/#entrypoint (https://docs.docker.com/engine/reference/builder/#entrypoint)
	// .
	EntryPoint []string

	// The environment variables to pass to a container. This parameter maps to Env in
	// the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --env option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . We don't recommend that you use plaintext environment variables for sensitive
	// information, such as credential data.
	Environment []KeyValuePair

	// A list of files containing the environment variables to pass to a container.
	// This parameter maps to the --env-file option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . You can specify up to ten environment files. The file must have a .env file
	// extension. Each line in an environment file contains an environment variable in
	// VARIABLE=VALUE format. Lines beginning with # are treated as comments and are
	// ignored. For more information about the environment variable file syntax, see
	// Declare default environment variables in file (https://docs.docker.com/compose/env-file/)
	// . If there are environment variables specified using the environment parameter
	// in a container definition, they take precedence over the variables contained
	// within an environment file. If multiple environment files are specified that
	// contain the same variable, they're processed from the top down. We recommend
	// that you use unique variable names. For more information, see Specifying
	// Environment Variables (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html)
	// in the Amazon Elastic Container Service Developer Guide.
	EnvironmentFiles []EnvironmentFile

	// 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 tasks 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 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Essential *bool

	// A list of hostnames and IP address mappings to append to the /etc/hosts file on
	// the container. This parameter maps to ExtraHosts in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --add-host option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . This parameter isn't supported for Windows containers or tasks that use the
	// awsvpc network mode.
	ExtraHosts []HostEntry

	// 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 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)
	// in the Amazon Elastic Container Service Developer Guide.
	FirelensConfiguration *FirelensConfiguration

	// The container health check command and associated configuration parameters for
	// the container. This parameter maps to HealthCheck in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the HEALTHCHECK parameter of docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// .
	HealthCheck *HealthCheck

	// The hostname to use for your container. This parameter maps to Hostname in the
	// Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --hostname option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . The hostname parameter is not supported if you're using the awsvpc network
	// mode.
	Hostname *string

	// 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 (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the IMAGE parameter of docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// .
	//   - When a new task starts, the Amazon ECS container agent pulls the latest
	//   version of the specified image and tag for the container to use. However,
	//   subsequent updates to a repository image aren't propagated to already running
	//   tasks.
	//   - Images in Amazon ECR repositories can be specified by either using the full
	//   registry/repository:tag or registry/repository@digest . For example,
	//   012345678910.dkr.ecr..amazonaws.com/:latest or
	//   012345678910.dkr.ecr..amazonaws.com/@sha256:94afd1f2e64d908bc90dbca0035a5b567EXAMPLE
	//   .
	//   - 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 ).
	Image *string

	// When this parameter is true , you can deploy containerized applications that
	// require stdin or a tty to be allocated. This parameter maps to OpenStdin in the
	// Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --interactive option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// .
	Interactive *bool

	// The links parameter allows containers to communicate with each other without
	// the need for port mappings. This parameter is only supported if the network mode
	// of a task definition is bridge . The name:internalName construct is analogous
	// to name:alias in Docker links. Up to 255 letters (uppercase and lowercase),
	// numbers, underscores, and hyphens are allowed. For more information about
	// linking Docker containers, go to Legacy container links (https://docs.docker.com/network/links/)
	// in the Docker documentation. This parameter maps to Links in the Create a
	// container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --link option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . This parameter is not supported for Windows containers. Containers that are
	// collocated on a single container instance may be able to communicate with each
	// other without requiring links or host port mappings. Network isolation is
	// achieved on the container instance using security groups and VPC settings.
	Links []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.
	LinuxParameters *LinuxParameters

	// The log configuration specification for the container. This parameter maps to
	// LogConfig in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --log-driver option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . 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 (https://docs.docker.com/engine/admin/logging/overview/)
	// 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 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
	// in the Amazon Elastic Container Service Developer Guide.
	LogConfiguration *LogConfiguration

	// The amount (in MiB) of memory to present to the container. If your container
	// attempts to exceed the memory specified here, the container is killed. The total
	// amount of memory reserved for all containers within a task must be lower than
	// the task memory value, if one is specified. This parameter maps to Memory in
	// the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --memory option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . If using the Fargate launch type, this parameter is optional. If using the EC2
	// launch type, you must specify either a task-level memory value or a
	// container-level memory value. If you specify both a container-level memory and
	// memoryReservation value, memory must be greater than memoryReservation . If you
	// specify memoryReservation , then that value is subtracted from the available
	// memory resources for the container instance where the container is placed.
	// Otherwise, the value of memory is used. The Docker 20.10.0 or later daemon
	// reserves a minimum of 6 MiB of memory for a container. So, don't specify less
	// than 6 MiB of memory for your containers. The Docker 19.03.13-ce or earlier
	// daemon reserves a minimum of 4 MiB of memory for a container. So, don't specify
	// less than 4 MiB of memory for your containers.
	Memory *int32

	// The soft limit (in MiB) of memory to reserve for the container. When system
	// memory is under heavy contention, Docker attempts to keep the container memory
	// to this soft limit. However, your container can consume more memory when it
	// needs to, up to either the hard limit specified with the memory parameter (if
	// applicable), or all of the available memory on the container instance, whichever
	// comes first. This parameter maps to MemoryReservation in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --memory-reservation option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . If a task-level memory value is not specified, you must specify a non-zero
	// integer for one or both of memory or memoryReservation in a container
	// definition. If you specify both, memory must be greater than memoryReservation .
	// If you specify memoryReservation , then that value is subtracted from the
	// available memory resources for the container instance where the container is
	// placed. Otherwise, the value of memory is used. For example, if your container
	// normally uses 128 MiB of memory, but occasionally bursts to 256 MiB of memory
	// for short periods of time, you can set a memoryReservation of 128 MiB, and a
	// memory hard limit of 300 MiB. This configuration would allow the container to
	// only reserve 128 MiB of memory from the remaining resources on the container
	// instance, but also allow the container to consume more memory resources when
	// needed. The Docker 20.10.0 or later daemon reserves a minimum of 6 MiB of memory
	// for a container. So, don't specify less than 6 MiB of memory for your
	// containers. The Docker 19.03.13-ce or earlier daemon reserves a minimum of 4 MiB
	// of memory for a container. So, don't specify less than 4 MiB of memory for your
	// containers.
	MemoryReservation *int32

	// The mount points for data volumes in your container. This parameter maps to
	// Volumes in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --volume option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . 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.
	MountPoints []MountPoint

	// The name of a container. If you're linking multiple containers together in a
	// task definition, the name of one container can be entered in the links of
	// another container to connect the containers. Up to 255 letters (uppercase and
	// lowercase), numbers, underscores, and hyphens are allowed. This parameter maps
	// to name in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --name option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// .
	Name *string

	// The list of port mappings for the container. Port mappings allow containers to
	// access ports on the host container instance to send or receive traffic. For task
	// definitions that use the awsvpc network mode, only specify the containerPort .
	// The hostPort can be left blank or it must be the same value as the containerPort
	// . Port mappings on Windows use the NetNAT gateway address rather than localhost
	// . There's no loopback for port mappings on Windows, so you can't access a
	// container's mapped port from the host itself. This parameter maps to
	// PortBindings in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --publish option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . If the network mode of a task definition is set to none , then you can't
	// specify port mappings. If the network mode of a task definition is set to host ,
	// then host ports must either be undefined or they must match the container port
	// in the port mapping. After a task reaches the RUNNING status, manual and
	// automatic host and container port assignments are visible in the Network
	// Bindings section of a container description for a selected task in the Amazon
	// ECS console. The assignments are also visible in the networkBindings section
	// DescribeTasks responses.
	PortMappings []PortMapping

	// 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 (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --privileged option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . This parameter is not supported for Windows containers or tasks run on
	// Fargate.
	Privileged *bool

	// When this parameter is true , a TTY is allocated. This parameter maps to Tty in
	// the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --tty option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// .
	PseudoTerminal *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 (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --read-only option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . This parameter is not supported for Windows containers.
	ReadonlyRootFilesystem *bool

	// 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 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Secrets []Secret

	// Time duration (in seconds) to wait before giving up on resolving dependencies
	// for a container. For example, you specify two containers in a task definition
	// with containerA having a dependency on containerB reaching a COMPLETE , SUCCESS
	// , or HEALTHY status. If a startTimeout value is specified for containerB and it
	// doesn't reach the desired status within that time then containerA gives up and
	// not start. This results in the task transitioning to a STOPPED state. When the
	// ECS_CONTAINER_START_TIMEOUT container agent configuration variable is used, it's
	// enforced independently from this start timeout value. For tasks using the
	// Fargate launch type, the task or service requires the following platforms:
	//   - Linux platform version 1.3.0 or later.
	//   - Windows platform version 1.0.0 or later.
	// For tasks using the EC2 launch type, your container instances require at least
	// version 1.26.0 of the container agent to use a container start timeout value.
	// However, we recommend using the latest container agent version. For information
	// about checking your agent version and updating to the latest version, see
	// Updating the Amazon ECS Container Agent (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html)
	// in the Amazon Elastic Container Service Developer Guide. If you're using an
	// Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1
	// of the ecs-init package. If your container instances are launched from version
	// 20190301 or later, then they contain the required versions of the container
	// agent and ecs-init . For more information, see Amazon ECS-optimized Linux AMI (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)
	// in the Amazon Elastic Container Service Developer Guide. The valid values are
	// 2-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. For tasks using the Fargate launch type,
	// the task or service requires the following platforms:
	//   - Linux platform version 1.3.0 or later.
	//   - Windows platform version 1.0.0 or later.
	// The max stop timeout value is 120 seconds and 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 or the ECS_CONTAINER_STOP_TIMEOUT
	// agent configuration variable are set, then the default values of 30 seconds for
	// Linux containers and 30 seconds on Windows containers are used. Your container
	// instances require at least version 1.26.0 of the container agent to use a
	// container stop timeout value. However, we recommend using the latest container
	// agent version. For information about checking your agent version and updating to
	// the latest version, see Updating the Amazon ECS Container Agent (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html)
	// in the Amazon Elastic Container Service Developer Guide. If you're using an
	// Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of
	// the ecs-init package. If your container instances are launched from version
	// 20190301 or later, then they contain the required versions of the container
	// agent and ecs-init . For more information, see Amazon ECS-optimized Linux AMI (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)
	// in the Amazon Elastic Container Service Developer Guide. The valid values are
	// 2-120 seconds.
	StopTimeout *int32

	// A list of namespaced kernel parameters to set in the container. This parameter
	// maps to Sysctls in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --sysctl option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . For example, you can configure net.ipv4.tcp_keepalive_time setting to
	// maintain longer lived connections.
	SystemControls []SystemControl

	// 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 (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --ulimit option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . Valid naming values are displayed in the Ulimit data type. 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.
	Ulimits []Ulimit

	// The user to use inside the container. This parameter maps to User in the Create
	// a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --user option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . 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:gid
	//   - uid:group
	// This parameter is not supported for Windows containers.
	User *string

	// Data volumes to mount from another container. This parameter maps to VolumesFrom
	// in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --volumes-from option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// .
	VolumesFrom []VolumeFrom

	// The working directory to run commands inside the container in. This parameter
	// maps to WorkingDir in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --workdir option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// .
	WorkingDirectory *string
	// contains filtered or unexported fields
}

type ContainerDependency 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.
	//   - HEALTHY - This condition validates that the dependent container passes its
	//   Docker health check before permitting other containers to start. This requires
	//   that the dependent container has health checks configured. This condition is
	//   confirmed only at task startup.
	//
	// This member is required.
	Condition ContainerCondition

	// The name of a container.
	//
	// This member is required.
	ContainerName *string
	// contains filtered or unexported fields
}

type ContainerInstance struct {

	// This parameter returns true if the agent is connected to Amazon ECS. An
	// instance with an agent that may be unhealthy or stopped return false . Only
	// instances connected to an agent can accept task placement requests.
	AgentConnected bool

	// The status of the most recent agent update. If an update wasn't ever requested,
	// this value is NULL .
	AgentUpdateStatus AgentUpdateStatus

	// The resources attached to a container instance, such as an elastic network
	// interface.
	Attachments []Attachment

	// The attributes set for the container instance, either by the Amazon ECS
	// container agent at instance registration or manually with the PutAttributes
	// operation.
	Attributes []Attribute

	// The capacity provider that's associated with the container instance.
	CapacityProviderName *string

	// The Amazon Resource Name (ARN) of the container instance. For more information
	// about the ARN format, see Amazon Resource Name (ARN) (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#ecs-resource-ids)
	// in the Amazon ECS Developer Guide.
	ContainerInstanceArn *string

	// The ID of the container instance. For Amazon EC2 instances, this value is the
	// Amazon EC2 instance ID. For external instances, this value is the Amazon Web
	// Services Systems Manager managed instance ID.
	Ec2InstanceId *string

	// An object representing the health status of the container instance.
	HealthStatus *ContainerInstanceHealthStatus

	// The number of tasks on the container instance that are in the PENDING status.
	PendingTasksCount int32

	// The Unix timestamp for the time when the container instance was registered.
	RegisteredAt *time.Time

	// For CPU and memory resource types, this parameter describes the amount of each
	// resource that was available on the container instance when the container agent
	// registered it with Amazon ECS. This value represents the total amount of CPU and
	// memory that can be allocated on this container instance to tasks. For port
	// resource types, this parameter describes the ports that were reserved by the
	// Amazon ECS container agent when it registered the container instance with Amazon
	// ECS.
	RegisteredResources []Resource

	// For CPU and memory resource types, this parameter describes the remaining CPU
	// and memory that wasn't already allocated to tasks and is therefore available for
	// new tasks. For port resource types, this parameter describes the ports that were
	// reserved by the Amazon ECS container agent (at instance registration time) and
	// any task containers that have reserved port mappings on the host (with the host
	// or bridge network mode). Any port that's not specified here is available for
	// new tasks.
	RemainingResources []Resource

	// The number of tasks on the container instance that have a desired status (
	// desiredStatus ) of RUNNING .
	RunningTasksCount int32

	// The status of the container instance. The valid values are REGISTERING ,
	// REGISTRATION_FAILED , ACTIVE , INACTIVE , DEREGISTERING , or DRAINING . If your
	// account has opted in to the awsvpcTrunking account setting, then any newly
	// registered container instance will transition to a REGISTERING status while the
	// trunk elastic network interface is provisioned for the instance. If the
	// registration fails, the instance will transition to a REGISTRATION_FAILED
	// status. You can describe the container instance and see the reason for failure
	// in the statusReason parameter. Once the container instance is terminated, the
	// instance transitions to a DEREGISTERING status while the trunk elastic network
	// interface is deprovisioned. The instance then transitions to an INACTIVE
	// status. The ACTIVE status indicates that the container instance can accept
	// tasks. The DRAINING indicates that new tasks aren't placed on the container
	// instance and any service tasks running on the container instance are removed if
	// possible. For more information, see Container instance draining (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-draining.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Status *string

	// The reason that the container instance reached its current status.
	StatusReason *string

	// The metadata that you apply to the container instance to help you categorize
	// and organize them. Each tag consists of a key and an optional value. You define
	// both. The following basic restrictions apply to tags:
	//   - Maximum number of tags per resource - 50
	//   - For each resource, each tag key must be unique, and each tag key can have
	//   only one value.
	//   - Maximum key length - 128 Unicode characters in UTF-8
	//   - Maximum value length - 256 Unicode characters in UTF-8
	//   - If your tagging schema is used across multiple services and resources,
	//   remember that other services may have restrictions on allowed characters.
	//   Generally allowed characters are: letters, numbers, and spaces representable in
	//   UTF-8, and the following characters: + - = . _ : / @.
	//   - Tag keys and values are case-sensitive.
	//   - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
	//   prefix for either keys or values as it is reserved for Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	Tags []Tag

	// The version counter for the container instance. Every time a container instance
	// experiences a change that triggers a CloudWatch event, the version counter is
	// incremented. If you're replicating your Amazon ECS container instance state with
	// CloudWatch Events, you can compare the version of a container instance reported
	// by the Amazon ECS APIs with the version reported in CloudWatch Events for the
	// container instance (inside the detail object) to verify that the version in
	// your event stream is current.
	Version int64

	// The version information for the Amazon ECS container agent and Docker daemon
	// running on the container instance.
	VersionInfo *VersionInfo
	// contains filtered or unexported fields
}

type ContainerInstanceField string

type ContainerInstanceHealthStatus struct {

	// An array of objects representing the details of the container instance health
	// status.
	Details []InstanceHealthCheckResult

	// The overall health status of the container instance. This is an aggregate
	// status of all container instance health checks.
	OverallStatus InstanceHealthCheckState
	// contains filtered or unexported fields
}

type ContainerInstanceStatus string

type ContainerOverride struct {

	// The command to send to the container that overrides the default command from
	// the Docker image or the task definition. You must also specify a container name.
	Command []string

	// The number of cpu units reserved for the container, instead of the default
	// value from the task definition. You must also specify a container name.
	Cpu *int32

	// 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 task definition. You
	// must also specify a container name.
	Environment []KeyValuePair

	// A list of files containing the environment variables to pass to a container,
	// instead of the value from the container definition.
	EnvironmentFiles []EnvironmentFile

	// The hard limit (in MiB) of memory to present to the container, instead of the
	// default value from the task definition. If your container attempts to exceed the
	// memory specified here, the container is killed. You must also specify a
	// container name.
	Memory *int32

	// The soft limit (in MiB) of memory to reserve for the container, instead of the
	// default value from the task definition. You must also specify a container name.
	MemoryReservation *int32

	// The name of the container that receives the override. This parameter is
	// required if any override is specified.
	Name *string

	// The type and amount of a resource to assign to a container, instead of the
	// default value from the task definition. The only supported resource is a GPU.
	ResourceRequirements []ResourceRequirement
	// contains filtered or unexported fields
}

type ContainerStateChange struct {

	// The name of the container.
	ContainerName *string

	// The exit code for the container, if the state change is a result of the
	// container exiting.
	ExitCode *int32

	// The container image SHA 256 digest.
	ImageDigest *string

	// Any network bindings that are associated with the container.
	NetworkBindings []NetworkBinding

	// The reason for the state change.
	Reason *string

	// The ID of the Docker container.
	RuntimeId *string

	// The status of the container.
	Status *string
	// contains filtered or unexported fields
}

type Deployment struct {

	// The capacity provider strategy that the deployment is using.
	CapacityProviderStrategy []CapacityProviderStrategyItem

	// The Unix timestamp for the time when the service deployment was created.
	CreatedAt *time.Time

	// The most recent desired count of tasks that was specified for the service to
	// deploy or maintain.
	DesiredCount int32

	// The number of consecutively failed tasks in the deployment. A task is
	// considered a failure if the service scheduler can't launch the task, the task
	// doesn't transition to a RUNNING state, or if it fails any of its defined health
	// checks and is stopped. Once a service deployment has one or more successfully
	// running tasks, the failed task count resets to zero and stops being evaluated.
	FailedTasks int32

	// The ID of the deployment.
	Id *string

	// The launch type the tasks in the service are using. For more information, see
	// Amazon ECS Launch Types (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
	// in the Amazon Elastic Container Service Developer Guide.
	LaunchType LaunchType

	// The VPC subnet and security group configuration for tasks that receive their
	// own elastic network interface by using the awsvpc networking mode.
	NetworkConfiguration *NetworkConfiguration

	// The number of tasks in the deployment that are in the PENDING status.
	PendingCount int32

	// The operating system that your tasks in the service, or tasks are running on. A
	// platform family is specified only for tasks using the Fargate launch type. All
	// tasks that run as part of this service must use the same platformFamily value
	// as the service, for example, LINUX. .
	PlatformFamily *string

	// The platform version that your tasks in the service run on. A platform version
	// is only specified for tasks using the Fargate launch type. If one isn't
	// specified, the LATEST platform version is used. For more information, see
	// Fargate Platform Versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
	// in the Amazon Elastic Container Service Developer Guide.
	PlatformVersion *string

	// The rolloutState of a service is only returned for services that use the
	// rolling update ( ECS ) deployment type that aren't behind a Classic Load
	// Balancer. The rollout state of the deployment. When a service deployment is
	// started, it begins in an IN_PROGRESS state. When the service reaches a steady
	// state, the deployment transitions to a COMPLETED state. If the service fails to
	// reach a steady state and circuit breaker is turned on, the deployment
	// transitions to a FAILED state. A deployment in FAILED state doesn't launch any
	// new tasks. For more information, see DeploymentCircuitBreaker .
	RolloutState DeploymentRolloutState

	// A description of the rollout state of a deployment.
	RolloutStateReason *string

	// The number of tasks in the deployment that are in the RUNNING status.
	RunningCount int32

	// The details of the Service Connect configuration that's used by this
	// deployment. Compare the configuration between multiple deployments when
	// troubleshooting issues with new deployments. The configuration for this service
	// to discover and connect to services, and be discovered by, and connected from,
	// other services within a namespace. Tasks that run in a namespace can use short
	// names to connect to services in the namespace. Tasks can connect to services
	// across all of the clusters in the namespace. Tasks connect through a managed
	// proxy container that collects logs and metrics for increased visibility. Only
	// the tasks that Amazon ECS services create are supported with Service Connect.
	// For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectConfiguration *ServiceConnectConfiguration

	// The list of Service Connect resources that are associated with this deployment.
	// Each list entry maps a discovery name to a Cloud Map service name.
	ServiceConnectResources []ServiceConnectServiceResource

	// The status of the deployment. The following describes each state. PRIMARY The
	// most recent deployment of a service. ACTIVE A service deployment that still has
	// running tasks, but are in the process of being replaced with a new PRIMARY
	// deployment. INACTIVE A deployment that has been completely replaced.
	Status *string

	// The most recent task definition that was specified for the tasks in the service
	// to use.
	TaskDefinition *string

	// The Unix timestamp for the time when the service deployment was last updated.
	UpdatedAt *time.Time

	// The details of the volume that was configuredAtLaunch . You can configure
	// different settings like the size, throughput, volumeType, and ecryption in
	// ServiceManagedEBSVolumeConfiguration (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ServiceManagedEBSVolumeConfiguration.html)
	// . The name of the volume must match the name from the task definition.
	VolumeConfigurations []ServiceVolumeConfiguration
	// contains filtered or unexported fields
}

type DeploymentAlarms struct {

	// One or more CloudWatch alarm names. Use a "," to separate the alarms.
	//
	// This member is required.
	AlarmNames []string

	// Determines whether to use the CloudWatch alarm option in the service deployment
	// process.
	//
	// This member is required.
	Enable bool

	// Determines whether to configure Amazon ECS to roll back the service if a
	// service deployment fails. If rollback is used, when a service deployment fails,
	// the service is rolled back to the last deployment that completed successfully.
	//
	// This member is required.
	Rollback bool
	// contains filtered or unexported fields
}

type DeploymentCircuitBreaker struct {

	// Determines whether to use the deployment circuit breaker logic for the service.
	//
	// This member is required.
	Enable bool

	// Determines whether to configure Amazon ECS to roll back the service if a
	// service deployment fails. If rollback is on, when a service deployment fails,
	// the service is rolled back to the last deployment that completed successfully.
	//
	// This member is required.
	Rollback bool
	// contains filtered or unexported fields
}

type DeploymentConfiguration struct {

	// Information about the CloudWatch alarms.
	Alarms *DeploymentAlarms

	// The deployment circuit breaker can only be used for services using the rolling
	// update ( ECS ) deployment type. The deployment circuit breaker determines
	// whether a service deployment will fail if the service can't reach a steady
	// state. If you use the deployment circuit breaker, a service deployment will
	// transition to a failed state and stop launching new tasks. If you use the
	// rollback option, when a service deployment fails, the service is rolled back to
	// the last deployment that completed successfully. For more information, see
	// Rolling update (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html)
	// in the Amazon Elastic Container Service Developer Guide
	DeploymentCircuitBreaker *DeploymentCircuitBreaker

	// If a service is using the rolling update ( ECS ) deployment type, the
	// maximumPercent parameter represents an upper limit on the number of your
	// service's tasks that are allowed in the RUNNING or PENDING state during a
	// deployment, as a percentage of the desiredCount (rounded down to the nearest
	// integer). This parameter enables you to define the deployment batch size. For
	// example, if your service is using the REPLICA service scheduler and has a
	// desiredCount of four tasks and a maximumPercent value of 200%, the scheduler
	// may start four new tasks before stopping the four older tasks (provided that the
	// cluster resources required to do this are available). The default maximumPercent
	// value for a service using the REPLICA service scheduler is 200%. If a service
	// is using either the blue/green ( CODE_DEPLOY ) or EXTERNAL deployment types and
	// tasks that use the EC2 launch type, the maximum percent value is set to the
	// default value and is used to define the upper limit on the number of the tasks
	// in the service that remain in the RUNNING state while the container instances
	// are in the DRAINING state. If the tasks in the service use the Fargate launch
	// type, the maximum percent value is not used, although it is returned when
	// describing your service.
	MaximumPercent *int32

	// If a service is using the rolling update ( ECS ) deployment type, the
	// minimumHealthyPercent represents a lower limit on the number of your service's
	// tasks that must remain in the RUNNING state during a deployment, as a
	// percentage of the desiredCount (rounded up to the nearest integer). This
	// parameter enables you to deploy without using additional cluster capacity. For
	// example, if your service has a desiredCount of four tasks and a
	// minimumHealthyPercent of 50%, the service scheduler may stop two existing tasks
	// to free up cluster capacity before starting two new tasks. For services that do
	// not use a load balancer, the following should be noted:
	//   - A service is considered healthy if all essential containers within the
	//   tasks in the service pass their health checks.
	//   - If a task has no essential containers with a health check defined, the
	//   service scheduler will wait for 40 seconds after a task reaches a RUNNING
	//   state before the task is counted towards the minimum healthy percent total.
	//   - If a task has one or more essential containers with a health check defined,
	//   the service scheduler will wait for the task to reach a healthy status before
	//   counting it towards the minimum healthy percent total. A task is considered
	//   healthy when all essential containers within the task have passed their health
	//   checks. The amount of time the service scheduler can wait for is determined by
	//   the container health check settings.
	// For services that do use a load balancer, the following should be noted:
	//   - If a task has no essential containers with a health check defined, the
	//   service scheduler will wait for the load balancer target group health check to
	//   return a healthy status before counting the task towards the minimum healthy
	//   percent total.
	//   - If a task has an essential container with a health check defined, the
	//   service scheduler will wait for both the task to reach a healthy status and the
	//   load balancer target group health check to return a healthy status before
	//   counting the task towards the minimum healthy percent total.
	// The default value for a replica service for minimumHealthyPercent is 100%. The
	// default minimumHealthyPercent value for a service using the DAEMON service
	// schedule is 0% for the CLI, the Amazon Web Services SDKs, and the APIs and 50%
	// for the Amazon Web Services Management Console. The minimum number of healthy
	// tasks during a deployment is the desiredCount multiplied by the
	// minimumHealthyPercent /100, rounded up to the nearest integer value. If a
	// service is using either the blue/green ( CODE_DEPLOY ) or EXTERNAL deployment
	// types and is running tasks that use the EC2 launch type, the minimum healthy
	// percent value is set to the default value and is used to define the lower limit
	// on the number of the tasks in the service that remain in the RUNNING state
	// while the container instances are in the DRAINING state. If a service is using
	// either the blue/green ( CODE_DEPLOY ) or EXTERNAL deployment types and is
	// running tasks that use the Fargate launch type, the minimum healthy percent
	// value is not used, although it is returned when describing your service.
	MinimumHealthyPercent *int32
	// contains filtered or unexported fields
}

type DeploymentController struct {

	// The deployment controller type to use. There are three deployment controller
	// types available: ECS The rolling update ( ECS ) deployment type involves
	// replacing the current running version of the container with the latest version.
	// The number of containers Amazon ECS adds or removes from the service during a
	// rolling update is controlled by adjusting the minimum and maximum number of
	// healthy tasks allowed during a service deployment, as specified in the
	// DeploymentConfiguration . CODE_DEPLOY The blue/green ( CODE_DEPLOY ) deployment
	// type uses the blue/green deployment model powered by CodeDeploy, which allows
	// you to verify a new deployment of a service before sending production traffic to
	// it. EXTERNAL The external ( EXTERNAL ) deployment type enables you to use any
	// third-party deployment controller for full control over the deployment process
	// for an Amazon ECS service.
	//
	// This member is required.
	Type DeploymentControllerType
	// contains filtered or unexported fields
}

type DeploymentControllerType string

type DeploymentRolloutState string

type DesiredStatus string

type Device struct {

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

	// The path inside the container at which to expose the host device.
	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
	// contains filtered or unexported fields
}

type DeviceCgroupPermission string

type DockerVolumeConfiguration struct {

	// If this value is true , the Docker volume is created if it doesn't already
	// exist. This field is only used if the scope is shared .
	Autoprovision *bool

	// The Docker volume driver to use. The driver value must match the driver name
	// provided by Docker because it is used for task placement. If the driver was
	// installed using the Docker plugin CLI, use docker plugin ls to retrieve the
	// driver name from your container instance. If the driver was installed using
	// another method, use Docker plugin discovery to retrieve the driver name. For
	// more information, see Docker plugin discovery (https://docs.docker.com/engine/extend/plugin_api/#plugin-discovery)
	// . This parameter maps to Driver in the Create a volume (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the xxdriver option to docker volume create (https://docs.docker.com/engine/reference/commandline/volume_create/)
	// .
	Driver *string

	// A map of Docker driver-specific options passed through. This parameter maps to
	// DriverOpts in the Create a volume (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the xxopt option to docker volume create (https://docs.docker.com/engine/reference/commandline/volume_create/)
	// .
	DriverOpts map[string]string

	// Custom metadata to add to your Docker volume. This parameter maps to Labels in
	// the Create a volume (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the xxlabel option to docker volume create (https://docs.docker.com/engine/reference/commandline/volume_create/)
	// .
	Labels map[string]string

	// The scope for the Docker volume that determines its lifecycle. Docker volumes
	// that are scoped to a task are automatically provisioned when the task starts
	// and destroyed when the task stops. Docker volumes that are scoped as shared
	// persist after the task stops.
	Scope Scope
	// contains filtered or unexported fields
}

type EBSResourceType string

type EBSTagSpecification struct {

	// The type of volume resource.
	//
	// This member is required.
	ResourceType EBSResourceType

	// Determines whether to propagate the tags from the task definition to 
the
	// Amazon EBS volume. Tags can only propagate to a SERVICE specified in
	// ServiceVolumeConfiguration . If no value is specified, the tags aren't
	// 
propagated.
	PropagateTags PropagateTags

	// The tags applied to this Amazon EBS volume. AmazonECSCreated and
	// AmazonECSManaged are reserved tags that can't be used.
	Tags []Tag
	// contains filtered or unexported fields
}

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 will enforce the path set on the EFS access point. If
	// an access point is used, transit encryption must be on in the
	// EFSVolumeConfiguration . For more information, see Working with Amazon EFS
	// access points (https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html)
	// in the Amazon Elastic File System User Guide.
	AccessPointId *string

	// Determines whether to use the Amazon ECS task role defined in a task definition
	// when mounting the Amazon EFS file system. If it is turned on, transit encryption
	// must be turned on in the EFSVolumeConfiguration . If this parameter is omitted,
	// the default value of DISABLED is used. For more information, see Using Amazon
	// EFS access points (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints)
	// in the Amazon Elastic Container Service Developer Guide.
	Iam EFSAuthorizationConfigIAM
	// contains filtered or unexported fields
}

type EFSAuthorizationConfigIAM string

type EFSTransitEncryption string

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
	// will be used. Specifying / will have the same effect as omitting this
	// parameter. If an EFS access point is specified in the authorizationConfig , the
	// root directory parameter must either be omitted or set to / which will enforce
	// the path set on the EFS access point.
	RootDirectory *string

	// Determines whether to use encryption for Amazon EFS data in transit between the
	// Amazon ECS host and the Amazon EFS server. Transit encryption must be turned on
	// 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 (https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html)
	// in the Amazon Elastic File System User Guide.
	TransitEncryption EFSTransitEncryption

	// The port to use when sending encrypted data between the Amazon ECS host and the
	// Amazon EFS server. If you do not specify a transit encryption port, it will use
	// the port selection strategy that the Amazon EFS mount helper uses. For more
	// information, see EFS mount helper (https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html)
	// in the Amazon Elastic File System User Guide.
	TransitEncryptionPort *int32
	// contains filtered or unexported fields
}

type EnvironmentFile struct {

	// The file type to use. Environment files are objects in Amazon S3. The only
	// supported value is s3 .
	//
	// This member is required.
	Type EnvironmentFileType

	// The Amazon Resource Name (ARN) of the Amazon S3 object containing the
	// environment variable file.
	//
	// This member is required.
	Value *string
	// contains filtered or unexported fields
}

type EnvironmentFileType string

type EphemeralStorage struct {

	// The total amount, in GiB, of ephemeral storage to set for the task. The minimum
	// supported value is 20 GiB and the maximum supported value is 200 GiB.
	//
	// This member is required.
	SizeInGiB int32
	// contains filtered or unexported fields
}

type ExecuteCommandConfiguration struct {

	// Specify an Key Management Service key ID to encrypt the data between the local
	// client and the container.
	KmsKeyId *string

	// The log configuration for the results of the execute command actions. The logs
	// can be sent to CloudWatch Logs or an Amazon S3 bucket. When logging=OVERRIDE is
	// specified, a logConfiguration must be provided.
	LogConfiguration *ExecuteCommandLogConfiguration

	// The log setting to use for redirecting logs for your execute command results.
	// The following log settings are available.
	//   - NONE : The execute command session is not logged.
	//   - DEFAULT : The awslogs configuration in the task definition is used. If no
	//   logging parameter is specified, it defaults to this value. If no awslogs log
	//   driver is configured in the task definition, the output won't be logged.
	//   - OVERRIDE : Specify the logging details as a part of logConfiguration . If
	//   the OVERRIDE logging option is specified, the logConfiguration is required.
	Logging ExecuteCommandLogging
	// contains filtered or unexported fields
}

type ExecuteCommandLogConfiguration struct {

	// Determines whether to use encryption on the CloudWatch logs. If not specified,
	// encryption will be off.
	CloudWatchEncryptionEnabled bool

	// The name of the CloudWatch log group to send logs to. The CloudWatch log group
	// must already be created.
	CloudWatchLogGroupName *string

	// The name of the S3 bucket to send logs to. The S3 bucket must already be
	// created.
	S3BucketName *string

	// Determines whether to use encryption on the S3 logs. If not specified,
	// encryption is not used.
	S3EncryptionEnabled bool

	// An optional folder in the S3 bucket to place logs in.
	S3KeyPrefix *string
	// contains filtered or unexported fields
}

type ExecuteCommandLogging string

type FSxWindowsFileServerAuthorizationConfig struct {

	// The authorization credential option to use. The authorization credential
	// options can be provided using either the Amazon Resource Name (ARN) of an
	// Secrets Manager secret or SSM Parameter Store parameter. The ARN refers to the
	// stored credentials.
	//
	// This member is required.
	CredentialsParameter *string

	// A fully qualified domain name hosted by an Directory Service (https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)
	// Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.
	//
	// This member is required.
	Domain *string
	// contains filtered or unexported fields
}

type FSxWindowsFileServerVolumeConfiguration struct {

	// The authorization configuration details for the Amazon FSx for Windows File
	// Server file system.
	//
	// This member is required.
	AuthorizationConfig *FSxWindowsFileServerAuthorizationConfig

	// The Amazon FSx for Windows File Server file system ID to use.
	//
	// This member is required.
	FileSystemId *string

	// The directory within the Amazon FSx for Windows File Server file system to
	// mount as the root directory inside the host.
	//
	// This member is required.
	RootDirectory *string
	// contains filtered or unexported fields
}

type Failure struct {

	// The Amazon Resource Name (ARN) of the failed resource.
	Arn *string

	// The details of the failure.
	Detail *string

	// The reason for the failure.
	Reason *string
	// contains filtered or unexported fields
}

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 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html#firelens-taskdef)
	// in the Amazon Elastic Container Service Developer Guide. Tasks hosted on Fargate
	// only support the file configuration file type.
	Options map[string]string
	// contains filtered or unexported fields
}

type FirelensConfigurationType string

type HealthCheck struct {

	// A string array representing the command that the container runs to determine if
	// it is healthy. The string array must start with CMD to run the command
	// arguments directly, or CMD-SHELL to run the command with the container's
	// default shell. When you use the Amazon Web Services Management Console JSON
	// panel, the Command Line Interface, or the APIs, enclose the list of commands in
	// double quotes and brackets. [ "CMD-SHELL", "curl -f http://localhost/ || exit
	// 1" ] You don't include the double quotes and brackets when you use the Amazon
	// Web Services Management Console. CMD-SHELL, curl -f http://localhost/ || exit 1
	// An exit code of 0 indicates success, and non-zero exit code indicates failure.
	// For more information, see HealthCheck in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) .
	//
	// This member is required.
	Command []string

	// The time period in seconds between each health check execution. You may specify
	// between 5 and 300 seconds. The default value is 30 seconds.
	Interval *int32

	// The number of times to retry a failed health check before the container is
	// considered unhealthy. You may specify between 1 and 10 retries. The default
	// value is 3.
	Retries *int32

	// The optional grace period to provide containers time to bootstrap before failed
	// health checks count towards the maximum number of retries. You can specify
	// between 0 and 300 seconds. By default, the startPeriod is off. If a health
	// check succeeds within the startPeriod , then the container is considered healthy
	// and any subsequent failures count toward the maximum number of retries.
	StartPeriod *int32

	// The time period in seconds to wait for a health check to succeed before it is
	// considered a failure. You may specify between 2 and 60 seconds. The default
	// value is 5.
	Timeout *int32
	// contains filtered or unexported fields
}

type HealthStatus string

type HostEntry struct {

	// The hostname to use in the /etc/hosts entry.
	//
	// This member is required.
	Hostname *string

	// The IP address to use in the /etc/hosts entry.
	//
	// This member is required.
	IpAddress *string
	// contains filtered or unexported fields
}

type HostVolumeProperties struct {

	// When the host parameter is used, specify a sourcePath to declare 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 the host
	// parameter contains a sourcePath file location, then the data volume persists at
	// the specified location on the host container instance until you delete it
	// manually. If the sourcePath value 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. If you're using the Fargate launch type, the
	// sourcePath parameter is not supported.
	SourcePath *string
	// contains filtered or unexported fields
}

type InferenceAccelerator struct {

	// The Elastic Inference accelerator device name. The deviceName must also be
	// referenced in a container definition as a ResourceRequirement (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ResourceRequirement.html)
	// .
	//
	// This member is required.
	DeviceName *string

	// The Elastic Inference accelerator type to use.
	//
	// This member is required.
	DeviceType *string
	// contains filtered or unexported fields
}

type InferenceAcceleratorOverride struct {

	// The Elastic Inference accelerator device name to override for the task. This
	// parameter must match a deviceName specified in the task definition.
	DeviceName *string

	// The Elastic Inference accelerator type to use.
	DeviceType *string
	// contains filtered or unexported fields
}

type InstanceHealthCheckResult struct {

	// The Unix timestamp for when the container instance health status last changed.
	LastStatusChange *time.Time

	// The Unix timestamp for when the container instance health status was last
	// updated.
	LastUpdated *time.Time

	// The container instance health status.
	Status InstanceHealthCheckState

	// The type of container instance health status that was verified.
	Type InstanceHealthCheckType
	// contains filtered or unexported fields
}

type InstanceHealthCheckState string

type InstanceHealthCheckType string

type InvalidParameterException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type IpcMode string

type KernelCapabilities struct {

	// The Linux capabilities for the container that have been added to the default
	// configuration provided by Docker. This parameter maps to CapAdd in the Create a
	// container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --cap-add option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . Tasks launched on Fargate only support adding the SYS_PTRACE kernel
	// capability. Valid values: "ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" |
	// "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" |
	// "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" |
	// "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" |
	// "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" |
	// "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" |
	// "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" |
	// "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"
	Add []string

	// The Linux capabilities for the container that have been removed from the
	// default configuration provided by Docker. This parameter maps to CapDrop in the
	// Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --cap-drop option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . Valid values: "ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" |
	// "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK"
	// | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" |
	// "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" |
	// "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" |
	// "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" |
	// "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" |
	// "SYSLOG" | "WAKE_ALARM"
	Drop []string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type LaunchType string

type LimitExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type LinuxParameters struct {

	// The Linux capabilities for the container that are added to or dropped from the
	// default configuration provided by Docker. For tasks that use the Fargate launch
	// type, capabilities is supported for all platform versions but the add parameter
	// is only supported if using platform version 1.4.0 or later.
	Capabilities *KernelCapabilities

	// Any host devices to expose to the container. This parameter maps to Devices in
	// the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --device option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . If you're using tasks that use the Fargate launch type, the devices parameter
	// isn't supported.
	Devices []Device

	// Run an init process inside the container that forwards signals and reaps
	// processes. This parameter maps to the --init option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . 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 --format '{{.Server.APIVersion}}'
	InitProcessEnabled *bool

	// The total amount of swap memory (in MiB) a container can use. This parameter
	// will be translated to the --memory-swap option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// where the value would be the sum of the container memory plus the maxSwap
	// value. If a maxSwap value of 0 is specified, the container will not use swap.
	// Accepted values are 0 or any positive integer. If the maxSwap parameter is
	// omitted, the container will use the swap configuration for the container
	// instance it is running on. A maxSwap value must be set for the swappiness
	// parameter to be used. If you're using tasks that use the Fargate launch type,
	// the maxSwap parameter isn't supported. If you're using tasks on Amazon Linux
	// 2023 the swappiness parameter isn't supported.
	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 (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . If you are using tasks that use the Fargate launch type, the sharedMemorySize
	// parameter is not supported.
	SharedMemorySize *int32

	// This allows you to tune a container's memory swappiness behavior. A swappiness
	// value of 0 will cause swapping to not happen unless absolutely necessary. A
	// swappiness value of 100 will cause pages to be swapped very aggressively.
	// Accepted values are whole numbers between 0 and 100 . If the swappiness
	// parameter is not specified, a default value of 60 is used. If a value is not
	// specified for maxSwap then this parameter is ignored. This parameter maps to
	// the --memory-swappiness option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . If you're using tasks that use the Fargate launch type, the swappiness
	// parameter isn't supported. If you're using tasks on Amazon Linux 2023 the
	// swappiness parameter isn't supported.
	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 (https://docs.docker.com/engine/reference/run/#security-configuration)
	// . If you're using tasks that use the Fargate launch type, the tmpfs parameter
	// isn't supported.
	Tmpfs []Tmpfs
	// contains filtered or unexported fields
}

type LoadBalancer struct {

	// The name of the container (as it appears in a container definition) to
	// associate with the load balancer. You need to specify the container name when
	// configuring the target group for an Amazon ECS load balancer.
	ContainerName *string

	// The port on the container to associate with the load balancer. This port must
	// correspond to a containerPort in the task definition the tasks in the service
	// are using. For tasks that use the EC2 launch type, the container instance
	// they're launched on must allow ingress traffic on the hostPort of the port
	// mapping.
	ContainerPort *int32

	// The name of the load balancer to associate with the Amazon ECS service or task
	// set. If you are using an Application Load Balancer or a Network Load Balancer
	// the load balancer name parameter should be omitted.
	LoadBalancerName *string

	// The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group
	// or groups associated with a service or task set. A target group ARN is only
	// specified when using an Application Load Balancer or Network Load Balancer. For
	// services using the ECS deployment controller, you can specify one or multiple
	// target groups. For more information, see Registering multiple target groups
	// with a service (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html)
	// in the Amazon Elastic Container Service Developer Guide. For services using the
	// CODE_DEPLOY deployment controller, you're required to define two target groups
	// for the load balancer. For more information, see Blue/green deployment with
	// CodeDeploy (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html)
	// in the Amazon Elastic Container Service Developer Guide. If your service's task
	// definition uses the awsvpc network mode, you must choose ip as the target type,
	// not instance . Do this when creating your target groups because tasks that use
	// the awsvpc network mode are associated with an elastic network interface, not
	// an Amazon EC2 instance. This network mode is required for the Fargate launch
	// type.
	TargetGroupArn *string
	// contains filtered or unexported fields
}

type LogConfiguration struct {

	// The log driver to use for the container. For tasks on Fargate, the supported
	// log drivers are awslogs , splunk , and awsfirelens . For tasks hosted on Amazon
	// EC2 instances, the supported log drivers are awslogs , fluentd , gelf ,
	// json-file , journald , logentries , syslog , splunk , and awsfirelens . For more
	// information about using the awslogs log driver, see Using the awslogs log driver (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html)
	// in the Amazon Elastic Container Service Developer Guide. For more information
	// about using the awsfirelens log driver, see Custom log routing (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)
	// in the Amazon Elastic Container Service Developer Guide. If you have a custom
	// driver that isn't listed, you can fork the Amazon ECS container agent project
	// that's available on GitHub (https://github.com/aws/amazon-ecs-agent) and
	// customize it to work with that driver. We encourage you to submit pull requests
	// for changes that you would like to have included. However, we don't currently
	// provide support for running modified copies of this software.
	//
	// 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 --format
	// '{{.Server.APIVersion}}'
	Options map[string]string

	// The secrets to pass to the log configuration. For more information, see
	// Specifying sensitive data (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)
	// in the Amazon Elastic Container Service Developer Guide.
	SecretOptions []Secret
	// contains filtered or unexported fields
}

type LogDriver string

type ManagedAgent struct {

	// The Unix timestamp for the time when the managed agent was last started.
	LastStartedAt *time.Time

	// The last known status of the managed agent.
	LastStatus *string

	// The name of the managed agent. When the execute command feature is turned on,
	// the managed agent name is ExecuteCommandAgent .
	Name ManagedAgentName

	// The reason for why the managed agent is in the state it is in.
	Reason *string
	// contains filtered or unexported fields
}

type ManagedAgentName string

type ManagedAgentStateChange struct {

	// The name of the container that's associated with the managed agent.
	//
	// This member is required.
	ContainerName *string

	// The name of the managed agent.
	//
	// This member is required.
	ManagedAgentName ManagedAgentName

	// The status of the managed agent.
	//
	// This member is required.
	Status *string

	// The reason for the status of the managed agent.
	Reason *string
	// contains filtered or unexported fields
}

type ManagedDraining string

type ManagedScaling struct {

	// The period of time, in seconds, after a newly launched Amazon EC2 instance can
	// contribute to CloudWatch metrics for Auto Scaling group. If this parameter is
	// omitted, the default value of 300 seconds is used.
	InstanceWarmupPeriod *int32

	// The maximum number of Amazon EC2 instances that Amazon ECS will scale out at
	// one time. The scale in process is not affected by this parameter. If this
	// parameter is omitted, the default value of 10000 is used.
	MaximumScalingStepSize *int32

	// The minimum number of Amazon EC2 instances that Amazon ECS will scale out at
	// one time. The scale in process is not affected by this parameter If this
	// parameter is omitted, the default value of 1 is used. When additional capacity
	// is required, Amazon ECS will scale up the minimum scaling step size even if the
	// actual demand is less than the minimum scaling step size. If you use a capacity
	// provider with an Auto Scaling group configured with more than one Amazon EC2
	// instance type or Availability Zone, Amazon ECS will scale up by the exact
	// minimum scaling step size value and will ignore both the maximum scaling step
	// size as well as the capacity demand.
	MinimumScalingStepSize *int32

	// Determines whether to use managed scaling for the capacity provider.
	Status ManagedScalingStatus

	// The target capacity utilization as a percentage for the capacity provider. The
	// specified value must be greater than 0 and less than or equal to 100 . For
	// example, if you want the capacity provider to maintain 10% spare capacity, then
	// that means the utilization is 90%, so use a targetCapacity of 90 . The default
	// value of 100 percent results in the Amazon EC2 instances in your Auto Scaling
	// group being completely used.
	TargetCapacity *int32
	// contains filtered or unexported fields
}

type ManagedScalingStatus string

type ManagedTerminationProtection string

type MissingVersionException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type MountPoint struct {

	// The path on the container to mount the host volume at.
	ContainerPath *string

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

	// The name of the volume to mount. Must be a volume name referenced in the name
	// parameter of task definition volume .
	SourceVolume *string
	// contains filtered or unexported fields
}

type NamespaceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type NetworkBinding struct {

	// The IP address that the container is bound to on the container instance.
	BindIP *string

	// The port number on the container that's used with the network binding.
	ContainerPort *int32

	// The port number range on the container that's bound to the dynamically mapped
	// host port range. The following rules apply when you specify a containerPortRange
	// :
	//   - You must use either the bridge network mode or the awsvpc network mode.
	//   - This parameter is available for both the EC2 and Fargate launch types.
	//   - This parameter is available for both the Linux and Windows operating
	//   systems.
	//   - The container instance must have at least version 1.67.0 of the container
	//   agent and at least version 1.67.0-1 of the ecs-init package
	//   - You can specify a maximum of 100 port ranges per container.
	//   - You do not specify a hostPortRange . The value of the hostPortRange is set
	//   as follows:
	//   - For containers in a task with the awsvpc network mode, the hostPortRange is
	//   set to the same value as the containerPortRange . This is a static mapping
	//   strategy.
	//   - For containers in a task with the bridge network mode, the Amazon ECS agent
	//   finds open host ports from the default ephemeral range and passes it to docker
	//   to bind them to the container ports.
	//   - The containerPortRange valid values are between 1 and 65535.
	//   - A port can only be included in one port mapping per container.
	//   - You cannot specify overlapping port ranges.
	//   - The first port in the range must be less than last port in the range.
	//   - Docker recommends that you turn off the docker-proxy in the Docker daemon
	//   config file when you have a large number of ports. For more information, see
	//   Issue #11185 (https://github.com/moby/moby/issues/11185) on the Github
	//   website. For information about how to turn off the docker-proxy in the Docker
	//   daemon config file, see Docker daemon (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon)
	//   in the Amazon ECS Developer Guide.
	// You can call DescribeTasks (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html)
	// to view the hostPortRange which are the host ports that are bound to the
	// container ports.
	ContainerPortRange *string

	// The port number on the host that's used with the network binding.
	HostPort *int32

	// The port number range on the host that's used with the network binding. This is
	// assigned is assigned by Docker and delivered by the Amazon ECS agent.
	HostPortRange *string

	// The protocol used for the network binding.
	Protocol TransportProtocol
	// contains filtered or unexported fields
}

type NetworkConfiguration struct {

	// The VPC subnets and security groups that are associated with a task. All
	// specified subnets and security groups must be from the same VPC.
	AwsvpcConfiguration *AwsVpcConfiguration
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type NetworkMode string

type NoUpdateAvailableException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type OSFamily string

type PidMode string

type PlacementConstraint struct {

	// A cluster query language expression to apply to the constraint. The expression
	// can have a maximum length of 2000 characters. You can't specify an expression if
	// the constraint type is distinctInstance . For more information, see Cluster
	// query language (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Expression *string

	// The type of constraint. Use distinctInstance to ensure that each task in a
	// particular group is running on a different container instance. Use memberOf to
	// restrict the selection to a group of valid candidates.
	Type PlacementConstraintType
	// contains filtered or unexported fields
}

type PlacementConstraintType string

type PlacementStrategy struct {

	// The field to apply the placement strategy against. For the spread placement
	// strategy, valid values are instanceId (or host , which has the same effect), or
	// any platform or custom attribute that's applied to a container instance, such as
	// attribute:ecs.availability-zone . For the binpack placement strategy, valid
	// values are cpu and memory . For the random placement strategy, this field is
	// not used.
	Field *string

	// The type of placement strategy. The random placement strategy randomly places
	// tasks on available candidates. The spread placement strategy spreads placement
	// across available candidates evenly based on the field parameter. The binpack
	// strategy places tasks on available candidates that have the least available
	// amount of the resource that's specified with the field parameter. For example,
	// if you binpack on memory, a task is placed on the instance with the least amount
	// of remaining memory but still enough to run the task.
	Type PlacementStrategyType
	// contains filtered or unexported fields
}

type PlacementStrategyType string

type PlatformDevice struct {

	// The ID for the GPUs on the container instance. The available GPU IDs can also
	// be obtained on the container instance in the
	// /var/lib/ecs/gpu/nvidia_gpu_info.json file.
	//
	// This member is required.
	Id *string

	// The type of device that's available on the container instance. The only
	// supported value is GPU .
	//
	// This member is required.
	Type PlatformDeviceType
	// contains filtered or unexported fields
}

type PlatformDeviceType string

type PlatformTaskDefinitionIncompatibilityException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type PlatformUnknownException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type PortMapping struct {

	// The application protocol that's used for the port mapping. This parameter only
	// applies to Service Connect. We recommend that you set this parameter to be
	// consistent with the protocol that your application uses. If you set this
	// parameter, Amazon ECS adds protocol-specific connection handling to the Service
	// Connect proxy. If you set this parameter, Amazon ECS adds protocol-specific
	// telemetry in the Amazon ECS console and CloudWatch. If you don't set a value for
	// this parameter, then TCP is used. However, Amazon ECS doesn't add
	// protocol-specific telemetry for TCP. appProtocol is immutable in a Service
	// Connect service. Updating this field requires a service deletion and
	// redeployment. Tasks that run in a namespace can use short names to connect to
	// services in the namespace. Tasks can connect to services across all of the
	// clusters in the namespace. Tasks connect through a managed proxy container that
	// collects logs and metrics for increased visibility. Only the tasks that Amazon
	// ECS services create are supported with Service Connect. For more information,
	// see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	AppProtocol ApplicationProtocol

	// The port number on the container that's bound to the user-specified or
	// automatically assigned host port. If you use containers in a task with the
	// awsvpc or host network mode, specify the exposed ports using containerPort . If
	// you use containers in a task with the bridge network mode and you specify a
	// container port and not a host port, your container automatically receives a host
	// port in the ephemeral port range. For more information, see hostPort . Port
	// mappings that are automatically assigned in this way do not count toward the 100
	// reserved ports limit of a container instance.
	ContainerPort *int32

	// The port number range on the container that's bound to the dynamically mapped
	// host port range. The following rules apply when you specify a containerPortRange
	// :
	//   - You must use either the bridge network mode or the awsvpc network mode.
	//   - This parameter is available for both the EC2 and Fargate launch types.
	//   - This parameter is available for both the Linux and Windows operating
	//   systems.
	//   - The container instance must have at least version 1.67.0 of the container
	//   agent and at least version 1.67.0-1 of the ecs-init package
	//   - You can specify a maximum of 100 port ranges per container.
	//   - You do not specify a hostPortRange . The value of the hostPortRange is set
	//   as follows:
	//   - For containers in a task with the awsvpc network mode, the hostPortRange is
	//   set to the same value as the containerPortRange . This is a static mapping
	//   strategy.
	//   - For containers in a task with the bridge network mode, the Amazon ECS agent
	//   finds open host ports from the default ephemeral range and passes it to docker
	//   to bind them to the container ports.
	//   - The containerPortRange valid values are between 1 and 65535.
	//   - A port can only be included in one port mapping per container.
	//   - You cannot specify overlapping port ranges.
	//   - The first port in the range must be less than last port in the range.
	//   - Docker recommends that you turn off the docker-proxy in the Docker daemon
	//   config file when you have a large number of ports. For more information, see
	//   Issue #11185 (https://github.com/moby/moby/issues/11185) on the Github
	//   website. For information about how to turn off the docker-proxy in the Docker
	//   daemon config file, see Docker daemon (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon)
	//   in the Amazon ECS Developer Guide.
	// You can call DescribeTasks (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html)
	// to view the hostPortRange which are the host ports that are bound to the
	// container ports.
	ContainerPortRange *string

	// The port number on the container instance to reserve for your container. If you
	// specify a containerPortRange , leave this field empty and the value of the
	// hostPort is set as follows:
	//   - For containers in a task with the awsvpc network mode, the hostPort is set
	//   to the same value as the containerPort . This is a static mapping strategy.
	//   - For containers in a task with the bridge network mode, the Amazon ECS agent
	//   finds open ports on the host and automatically binds them to the container
	//   ports. This is a dynamic mapping strategy.
	// If you use containers in a task with the awsvpc or host network mode, the
	// hostPort can either be left blank or set to the same value as the containerPort
	// . If you use containers in a task with the bridge network mode, you can specify
	// a non-reserved host port for your container port mapping, or you can omit the
	// hostPort (or set it to 0 ) while specifying a containerPort and your container
	// automatically receives a port in the ephemeral port range for your container
	// instance operating system and Docker version. The default ephemeral port range
	// for Docker version 1.6.0 and later is listed on the instance under
	// /proc/sys/net/ipv4/ip_local_port_range . If this kernel parameter is
	// unavailable, the default ephemeral port range from 49153 through 65535 (Linux)
	// or 49152 through 65535 (Windows) is used. Do not attempt to specify a host port
	// in the ephemeral port range as these are reserved for automatic assignment. In
	// general, ports below 32768 are outside of the ephemeral port range. The default
	// reserved ports are 22 for SSH, the Docker ports 2375 and 2376, and the Amazon
	// ECS container agent ports 51678-51680. Any host port that was previously
	// specified in a running task is also reserved while the task is running. That is,
	// after a task stops, the host port is released. The current reserved ports are
	// displayed in the remainingResources of DescribeContainerInstances (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html)
	// output. A container instance can have up to 100 reserved ports at a time. This
	// number includes the default reserved ports. Automatically assigned ports aren't
	// included in the 100 reserved ports quota.
	HostPort *int32

	// The name that's used for the port mapping. This parameter only applies to
	// Service Connect. This parameter is the name that you use in the
	// serviceConnectConfiguration of a service. The name can include up to 64
	// characters. The characters can include lowercase letters, numbers, underscores
	// (_), and hyphens (-). The name can't start with a hyphen. For more information,
	// see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Name *string

	// The protocol used for the port mapping. Valid values are tcp and udp . The
	// default is tcp . protocol is immutable in a Service Connect service. Updating
	// this field requires a service deletion and redeployment.
	Protocol TransportProtocol
	// contains filtered or unexported fields
}

type PropagateTags string

type ProtectedTask struct {

	// The epoch time when protection for the task will expire.
	ExpirationDate *time.Time

	// The protection status of the task. If scale-in protection is on for a task, the
	// value is true . Otherwise, it is false .
	ProtectionEnabled bool

	// The task ARN.
	TaskArn *string
	// contains filtered or unexported fields
}

type ProxyConfiguration struct {

	// The name of the container that will serve as the App Mesh proxy.
	//
	// This member is required.
	ContainerName *string

	// The set of network configuration parameters to provide the Container Network
	// Interface (CNI) plugin, specified as key-value pairs.
	//   - IgnoredUID - (Required) The user ID (UID) of the proxy container as defined
	//   by the user parameter in a container definition. This is used to ensure the
	//   proxy ignores its own traffic. If IgnoredGID is specified, this field can be
	//   empty.
	//   - IgnoredGID - (Required) The group ID (GID) of the proxy container as defined
	//   by the user parameter in a container definition. This is used to ensure the
	//   proxy ignores its own traffic. If IgnoredUID is specified, this field can be
	//   empty.
	//   - AppPorts - (Required) The list of ports that the application uses. Network
	//   traffic to these ports is forwarded to the ProxyIngressPort and
	//   ProxyEgressPort .
	//   - ProxyIngressPort - (Required) Specifies the port that incoming traffic to
	//   the AppPorts is directed to.
	//   - ProxyEgressPort - (Required) Specifies the port that outgoing traffic from
	//   the AppPorts is directed to.
	//   - EgressIgnoredPorts - (Required) The egress traffic going to the specified
	//   ports is ignored and not redirected to the ProxyEgressPort . It can be an
	//   empty list.
	//   - EgressIgnoredIPs - (Required) The egress traffic going to the specified IP
	//   addresses is ignored and not redirected to the ProxyEgressPort . It can be an
	//   empty list.
	Properties []KeyValuePair

	// The proxy type. The only supported value is APPMESH .
	Type ProxyConfigurationType
	// contains filtered or unexported fields
}

type ProxyConfigurationType string

type RepositoryCredentials struct {

	// The Amazon Resource Name (ARN) of the secret containing the private repository
	// credentials. When you use the Amazon ECS API, CLI, or Amazon Web Services SDK,
	// if the secret exists in the same Region as the task that you're launching then
	// you can use either the full ARN or the name of the secret. When you use the
	// Amazon Web Services Management Console, you must specify the full ARN of the
	// secret.
	//
	// This member is required.
	CredentialsParameter *string
	// contains filtered or unexported fields
}

type Resource struct {

	// When the doubleValue type is set, the value of the resource must be a double
	// precision floating-point type.
	DoubleValue float64

	// When the integerValue type is set, the value of the resource must be an integer.
	IntegerValue int32

	// When the longValue type is set, the value of the resource must be an extended
	// precision floating-point type.
	LongValue int64

	// The name of the resource, such as CPU , MEMORY , PORTS , PORTS_UDP , or a
	// user-defined resource.
	Name *string

	// When the stringSetValue type is set, the value of the resource must be a string
	// type.
	StringSetValue []string

	// The type of the resource. Valid values: INTEGER , DOUBLE , LONG , or STRINGSET .
	Type *string
	// contains filtered or unexported fields
}

type ResourceInUseException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ResourceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ResourceRequirement struct {

	// The type of resource to assign to a container. The supported values are GPU or
	// InferenceAccelerator .
	//
	// This member is required.
	Type ResourceType

	// The value for the specified resource type. If the GPU type is used, the value
	// is the number of physical GPUs the Amazon ECS container agent reserves for the
	// container. The number of GPUs that's reserved for all containers in a task can't
	// exceed the number of available GPUs on the container instance that the task is
	// launched on. If the InferenceAccelerator type is used, the value matches the
	// deviceName for an InferenceAccelerator (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_InferenceAccelerator.html)
	// specified in a task definition.
	//
	// This member is required.
	Value *string
	// contains filtered or unexported fields
}

type ResourceType string

type RuntimePlatform struct {

	// The CPU architecture. You can run your Linux tasks on an ARM-based platform by
	// setting the value to ARM64 . This option is available for tasks that run on
	// Linux Amazon EC2 instance or Linux containers on Fargate.
	CpuArchitecture CPUArchitecture

	// The operating system.
	OperatingSystemFamily OSFamily
	// contains filtered or unexported fields
}

type Scale struct {

	// The unit of measure for the scale value.
	Unit ScaleUnit

	// The value, specified as a percent total of a service's desiredCount , to scale
	// the task set. Accepted values are numbers between 0 and 100.
	Value float64
	// contains filtered or unexported fields
}

type ScaleUnit string

type SchedulingStrategy string

type Scope string

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
	// ARN of the Secrets Manager secret or the full ARN of the parameter in the SSM
	// Parameter Store. For information about the require Identity and Access
	// Management permissions, see Required IAM permissions for Amazon ECS secrets (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-secrets.html#secrets-iam)
	// (for Secrets Manager) or Required IAM permissions for Amazon ECS secrets (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-parameters.html)
	// (for Systems Manager Parameter store) in the Amazon Elastic Container Service
	// Developer Guide. If the SSM Parameter Store parameter exists in the same Region
	// as the task you're launching, then you can use either the full 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
	// contains filtered or unexported fields
}

type ServerException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type Service struct {

	// The capacity provider strategy the service uses. When using the
	// DescribeServices API, this field is omitted if the service was created using a
	// launch type.
	CapacityProviderStrategy []CapacityProviderStrategyItem

	// The Amazon Resource Name (ARN) of the cluster that hosts the service.
	ClusterArn *string

	// The Unix timestamp for the time when the service was created.
	CreatedAt *time.Time

	// The principal that created the service.
	CreatedBy *string

	// Optional deployment parameters that control how many tasks run during the
	// deployment and the ordering of stopping and starting tasks.
	DeploymentConfiguration *DeploymentConfiguration

	// The deployment controller type the service is using.
	DeploymentController *DeploymentController

	// The current state of deployments for the service.
	Deployments []Deployment

	// The desired number of instantiations of the task definition to keep running on
	// the service. This value is specified when the service is created with
	// CreateService , and it can be modified with UpdateService .
	DesiredCount int32

	// Determines whether to use Amazon ECS managed tags for the tasks in the service.
	// For more information, see Tagging Your Amazon ECS Resources (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html)
	// in the Amazon Elastic Container Service Developer Guide.
	EnableECSManagedTags bool

	// Determines whether the execute command functionality is turned on for the
	// service. If true , the execute command functionality is turned on for all
	// containers in tasks as part of the service.
	EnableExecuteCommand bool

	// The event stream for your service. A maximum of 100 of the latest events are
	// displayed.
	Events []ServiceEvent

	// The period of time, in seconds, that the Amazon ECS service scheduler ignores
	// unhealthy Elastic Load Balancing target health checks after a task has first
	// started.
	HealthCheckGracePeriodSeconds *int32

	// The launch type the service is using. When using the DescribeServices API, this
	// field is omitted if the service was created using a capacity provider strategy.
	LaunchType LaunchType

	// A list of Elastic Load Balancing load balancer objects. It contains the load
	// balancer name, the container name, and the container port to access from the
	// load balancer. The container name is as it appears in a container definition.
	LoadBalancers []LoadBalancer

	// The VPC subnet and security group configuration for tasks that receive their
	// own elastic network interface by using the awsvpc networking mode.
	NetworkConfiguration *NetworkConfiguration

	// The number of tasks in the cluster that are in the PENDING state.
	PendingCount int32

	// The placement constraints for the tasks in the service.
	PlacementConstraints []PlacementConstraint

	// The placement strategy that determines how tasks for the service are placed.
	PlacementStrategy []PlacementStrategy

	// The operating system that your tasks in the service run on. A platform family
	// is specified only for tasks using the Fargate launch type. All tasks that run as
	// part of this service must use the same platformFamily value as the service (for
	// example, LINUX ).
	PlatformFamily *string

	// The platform version to run your service on. A platform version is only
	// specified for tasks that are hosted on Fargate. If one isn't specified, the
	// LATEST platform version is used. For more information, see Fargate Platform
	// Versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
	// in the Amazon Elastic Container Service Developer Guide.
	PlatformVersion *string

	// Determines whether to propagate the tags from the task definition or the
	// service to the task. If no value is specified, the tags aren't propagated.
	PropagateTags PropagateTags

	// The ARN of the IAM role that's associated with the service. It allows the
	// Amazon ECS container agent to register container instances with an Elastic Load
	// Balancing load balancer.
	RoleArn *string

	// The number of tasks in the cluster that are in the RUNNING state.
	RunningCount int32

	// The scheduling strategy to use for the service. For more information, see
	// Services (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html)
	// . There are two service scheduler strategies available.
	//   - REPLICA -The replica scheduling strategy places and maintains the desired
	//   number of tasks across your cluster. By default, the service scheduler spreads
	//   tasks across Availability Zones. You can use task placement strategies and
	//   constraints to customize task placement decisions.
	//   - DAEMON -The daemon scheduling strategy deploys exactly one task on each
	//   active container instance. This task meets all of the task placement constraints
	//   that you specify in your cluster. The service scheduler also evaluates the task
	//   placement constraints for running tasks. It stop tasks that don't meet the
	//   placement constraints. Fargate tasks don't support the DAEMON scheduling
	//   strategy.
	SchedulingStrategy SchedulingStrategy

	// The ARN that identifies the service. For more information about the ARN format,
	// see Amazon Resource Name (ARN) (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#ecs-resource-ids)
	// in the Amazon ECS Developer Guide.
	ServiceArn *string

	// The name of your service. Up to 255 letters (uppercase and lowercase), numbers,
	// underscores, and hyphens are allowed. Service names must be unique within a
	// cluster. However, you can have similarly named services in multiple clusters
	// within a Region or across multiple Regions.
	ServiceName *string

	// The details for the service discovery registries to assign to this service. For
	// more information, see Service Discovery (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html)
	// .
	ServiceRegistries []ServiceRegistry

	// The status of the service. The valid values are ACTIVE , DRAINING , or INACTIVE .
	Status *string

	// The metadata that you apply to the service to help you categorize and organize
	// them. Each tag consists of a key and an optional value. You define bot the key
	// and value. The following basic restrictions apply to tags:
	//   - Maximum number of tags per resource - 50
	//   - For each resource, each tag key must be unique, and each tag key can have
	//   only one value.
	//   - Maximum key length - 128 Unicode characters in UTF-8
	//   - Maximum value length - 256 Unicode characters in UTF-8
	//   - If your tagging schema is used across multiple services and resources,
	//   remember that other services may have restrictions on allowed characters.
	//   Generally allowed characters are: letters, numbers, and spaces representable in
	//   UTF-8, and the following characters: + - = . _ : / @.
	//   - Tag keys and values are case-sensitive.
	//   - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
	//   prefix for either keys or values as it is reserved for Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	Tags []Tag

	// The task definition to use for tasks in the service. This value is specified
	// when the service is created with CreateService , and it can be modified with
	// UpdateService .
	TaskDefinition *string

	// Information about a set of Amazon ECS tasks in either an CodeDeploy or an
	// EXTERNAL deployment. An Amazon ECS task set includes details such as the desired
	// number of tasks, how many tasks are running, and whether the task set serves
	// production traffic.
	TaskSets []TaskSet
	// contains filtered or unexported fields
}

type ServiceConnectClientAlias struct {

	// The listening port number for the Service Connect proxy. This port is available
	// inside of all of the tasks within the same namespace. To avoid changing your
	// applications in client Amazon ECS services, set this to the same port that the
	// client application uses by default. For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	// This member is required.
	Port *int32

	// The dnsName is the name that you use in the applications of client tasks to
	// connect to this service. The name must be a valid DNS name but doesn't need to
	// be fully-qualified. The name can include up to 127 characters. The name can
	// include lowercase letters, numbers, underscores (_), hyphens (-), and periods
	// (.). The name can't start with a hyphen. If this parameter isn't specified, the
	// default value of discoveryName.namespace is used. If the discoveryName isn't
	// specified, the port mapping name from the task definition is used in
	// portName.namespace . To avoid changing your applications in client Amazon ECS
	// services, set this to the same name that the client application uses by default.
	// For example, a few common names are database , db , or the lowercase name of a
	// database, such as mysql or redis . For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	DnsName *string
	// contains filtered or unexported fields
}

type ServiceConnectConfiguration struct {

	// Specifies whether to use Service Connect with this service.
	//
	// This member is required.
	Enabled bool

	// The log configuration for the container. This parameter maps to LogConfig in
	// the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
	// and the --log-driver option to docker run (https://docs.docker.com/engine/reference/commandline/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 configuration in the container
	// definition. For more information about the options for different supported log
	// drivers, see Configure logging drivers (https://docs.docker.com/engine/admin/logging/overview/)
	// in the Docker documentation. Understand the following when specifying a log
	// configuration for your containers.
	//   - Amazon ECS currently supports a subset of the logging drivers available to
	//   the Docker daemon. Additional log drivers may be available in future releases of
	//   the Amazon ECS container agent. For tasks on Fargate, the supported log drivers
	//   are awslogs , splunk , and awsfirelens . For tasks hosted on Amazon EC2
	//   instances, the supported log drivers are awslogs , fluentd , gelf , json-file
	//   , journald , logentries , syslog , splunk , and awsfirelens .
	//   - This parameter requires version 1.18 of the Docker Remote API or greater on
	//   your container instance.
	//   - For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container
	//   agent must register the available logging drivers 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 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
	//   in the Amazon Elastic Container Service Developer Guide.
	//   - For tasks that are on Fargate, because you don't have access to the
	//   underlying infrastructure your tasks are hosted on, any additional software
	//   needed must be installed outside of the task. For example, the Fluentd output
	//   aggregators or a remote host running Logstash to send Gelf logs to.
	LogConfiguration *LogConfiguration

	// The namespace name or full Amazon Resource Name (ARN) of the Cloud Map
	// namespace for use with Service Connect. The namespace must be in the same Amazon
	// Web Services Region as the Amazon ECS service and cluster. The type of namespace
	// doesn't affect Service Connect. For more information about Cloud Map, see
	// Working with Services (https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html)
	// in the Cloud Map Developer Guide.
	Namespace *string

	// The list of Service Connect service objects. These are names and aliases (also
	// known as endpoints) that are used by other Amazon ECS services to connect to
	// this service. This field is not required for a "client" Amazon ECS service
	// that's a member of a namespace only to connect to other services within the
	// namespace. An example of this would be a frontend application that accepts
	// incoming requests from either a load balancer that's attached to the service or
	// by other means. An object selects a port from the task definition, assigns a
	// name for the Cloud Map service, and a list of aliases (endpoints) and ports for
	// client applications to refer to this service.
	Services []ServiceConnectService
	// contains filtered or unexported fields
}

type ServiceConnectService struct {

	// The portName must match the name of one of the portMappings from all the
	// containers in the task definition of this Amazon ECS service.
	//
	// This member is required.
	PortName *string

	// The list of client aliases for this Service Connect service. You use these to
	// assign names that can be used by client applications. The maximum number of
	// client aliases that you can have in this list is 1. Each alias ("endpoint") is a
	// fully-qualified name and port number that other Amazon ECS tasks ("clients") can
	// use to connect to this service. Each name and port mapping must be unique within
	// the namespace. For each ServiceConnectService , you must provide at least one
	// clientAlias with one port .
	ClientAliases []ServiceConnectClientAlias

	// The discoveryName is the name of the new Cloud Map service that Amazon ECS
	// creates for this Amazon ECS service. This must be unique within the Cloud Map
	// namespace. The name can contain up to 64 characters. The name can include
	// lowercase letters, numbers, underscores (_), and hyphens (-). The name can't
	// start with a hyphen. If the discoveryName isn't specified, the port mapping
	// name from the task definition is used in portName.namespace .
	DiscoveryName *string

	// The port number for the Service Connect proxy to listen on. Use the value of
	// this field to bypass the proxy for traffic on the port number specified in the
	// named portMapping in the task definition of this application, and then use it
	// in your VPC security groups to allow traffic into the proxy for this Amazon ECS
	// service. In awsvpc mode and Fargate, the default value is the container port
	// number. The container port number is in the portMapping in the task definition.
	// In bridge mode, the default value is the ephemeral port of the Service Connect
	// proxy.
	IngressPortOverride *int32

	// A reference to an object that represents the configured timeouts for Service
	// Connect.
	Timeout *TimeoutConfiguration

	// A reference to an object that represents a Transport Layer Security (TLS)
	// configuration.
	Tls *ServiceConnectTlsConfiguration
	// contains filtered or unexported fields
}

type ServiceConnectServiceResource struct {

	// The Amazon Resource Name (ARN) for the namespace in Cloud Map that matches the
	// discovery name for this Service Connect resource. You can use this ARN in other
	// integrations with Cloud Map. However, Service Connect can't ensure connectivity
	// outside of Amazon ECS.
	DiscoveryArn *string

	// The discovery name of this Service Connect resource. The discoveryName is the
	// name of the new Cloud Map service that Amazon ECS creates for this Amazon ECS
	// service. This must be unique within the Cloud Map namespace. The name can
	// contain up to 64 characters. The name can include lowercase letters, numbers,
	// underscores (_), and hyphens (-). The name can't start with a hyphen. If the
	// discoveryName isn't specified, the port mapping name from the task definition is
	// used in portName.namespace .
	DiscoveryName *string
	// contains filtered or unexported fields
}

type ServiceConnectTlsCertificateAuthority struct {

	// The ARN of the Amazon Web Services Private Certificate Authority certificate.
	AwsPcaAuthorityArn *string
	// contains filtered or unexported fields
}

type ServiceConnectTlsConfiguration struct {

	// The signer certificate authority.
	//
	// This member is required.
	IssuerCertificateAuthority *ServiceConnectTlsCertificateAuthority

	// The Amazon Web Services Key Management Service key.
	KmsKey *string

	// The Amazon Resource Name (ARN) of the IAM role that's associated with the
	// Service Connect TLS.
	RoleArn *string
	// contains filtered or unexported fields
}

type ServiceEvent struct {

	// The Unix timestamp for the time when the event was triggered.
	CreatedAt *time.Time

	// The ID string for the event.
	Id *string

	// The event message.
	Message *string
	// contains filtered or unexported fields
}

type ServiceField string

type ServiceManagedEBSVolumeConfiguration struct {

	// The ARN of the IAM role to associate with this volume. This is the Amazon ECS
	// infrastructure IAM role that is used to manage your Amazon Web Services
	// infrastructure. We recommend using the Amazon ECS-managed
	// AmazonECSInfrastructureRolePolicyForVolumes IAM policy with this role. For more
	// information, see Amazon ECS infrastructure IAM role (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html)
	// in the Amazon ECS Developer Guide.
	//
	// This member is required.
	RoleArn *string

	// Indicates whether the volume should be encrypted. If no value is specified,
	// encryption is turned on by default. This parameter maps 1:1 with the Encrypted
	// parameter of the CreateVolume API (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)
	// in the Amazon EC2 API Reference.
	Encrypted *bool

	// The Linux filesystem type for the volume. For volumes created from a snapshot,
	// you must specify the same filesystem type that the volume was using when the
	// snapshot was created. If there is a filesystem type mismatch, the task will fail
	// to start. The available filesystem types are
 ext3 , ext4 , and xfs . If no
	// value is specified, the xfs filesystem type is used by default.
	FilesystemType TaskFilesystemType

	// The number of I/O operations per second (IOPS). For gp3 , io1 , and io2
	// volumes, this represents the number of IOPS that are provisioned for the volume.
	// For gp2 volumes, this represents the baseline performance of the volume and the
	// rate at which the volume accumulates I/O credits for bursting. The following are
	// the supported values for each volume type.
	//   - gp3 : 3,000 - 16,000 IOPS
	//   - io1 : 100 - 64,000 IOPS
	//   - io2 : 100 - 256,000 IOPS
	// This parameter is required for io1 and io2 volume types. The default for gp3
	// volumes is 3,000 IOPS . This parameter is not supported for st1 , sc1 , or
	// standard volume types. This parameter maps 1:1 with the Iops parameter of the
	// CreateVolume API (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)
	// in the Amazon EC2 API Reference.
	Iops *int32

	// The Amazon Resource Name (ARN) identifier of the Amazon Web Services Key
	// Management Service key to use for Amazon EBS encryption. When encryption is
	// turned on and no Amazon Web Services Key Management Service key is specified,
	// the default Amazon Web Services managed key for Amazon EBS volumes is used. This
	// parameter maps 1:1 with the KmsKeyId parameter of the CreateVolume API (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)
	// in the Amazon EC2 API Reference. Amazon Web Services authenticates the Amazon
	// Web Services Key Management Service key asynchronously. Therefore, if you
	// specify an ID, alias, or ARN that is invalid, the action can appear to complete,
	// but eventually fails.
	KmsKeyId *string

	// The size of the volume in GiB. You must specify either a volume size or a
	// snapshot ID. If you specify a snapshot ID, the snapshot size is used for the
	// volume size by default. You can optionally specify a volume size greater than or
	// equal to the snapshot size. This parameter maps 1:1 with the Size parameter of
	// the CreateVolume API (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)
	// in the Amazon EC2 API Reference. The following are the supported volume size
	// values for each volume type.
	//   - gp2 and gp3 : 1-16,384
	//   - io1 and io2 : 4-16,384
	//   - st1 and sc1 : 125-16,384
	//   - standard : 1-1,024
	SizeInGiB *int32

	// The snapshot that Amazon ECS uses to create the volume. You must specify either
	// a snapshot ID or a volume size. This parameter maps 1:1 with the SnapshotId
	// parameter of the CreateVolume API (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)
	// in the Amazon EC2 API Reference.
	SnapshotId *string

	// The tags to apply to the volume. Amazon ECS applies service-managed tags by
	// default. This parameter maps 1:1 with the TagSpecifications.N parameter of the
	// CreateVolume API (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)
	// in the Amazon EC2 API Reference.
	TagSpecifications []EBSTagSpecification

	// The throughput to provision for a volume, in MiB/s, with a maximum of 1,000
	// MiB/s. This parameter maps 1:1 with the Throughput parameter of the
	// CreateVolume API (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)
	// in the Amazon EC2 API Reference. This parameter is only supported for the gp3
	// volume type.
	Throughput *int32

	// The volume type. This parameter maps 1:1 with the VolumeType parameter of the
	// CreateVolume API (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)
	// in the Amazon EC2 API Reference. For more information, see Amazon EBS volume
	// types (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html)
	// in the Amazon EC2 User Guide. The following are the supported volume types.
	//   - General Purpose SSD: gp2 | gp3
	//   - Provisioned IOPS SSD: io1 | io2
	//   - Throughput Optimized HDD: st1
	//   - Cold HDD: sc1
	//   - Magnetic: standard The magnetic volume type is not supported on Fargate.
	VolumeType *string
	// contains filtered or unexported fields
}

type ServiceNotActiveException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ServiceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ServiceRegistry struct {

	// The container name value to be used for your service discovery service. It's
	// already specified in the task definition. If the task definition that your
	// service task specifies uses the bridge or host network mode, you must specify a
	// containerName and containerPort combination from the task definition. If the
	// task definition that your service task specifies uses the awsvpc network mode
	// and a type SRV DNS record is used, you must specify either a containerName and
	// containerPort combination or a port value. However, you can't specify both.
	ContainerName *string

	// The port value to be used for your service discovery service. It's already
	// specified in the task definition. If the task definition your service task
	// specifies uses the bridge or host network mode, you must specify a containerName
	// and containerPort combination from the task definition. If the task definition
	// your service task specifies uses the awsvpc network mode and a type SRV DNS
	// record is used, you must specify either a containerName and containerPort
	// combination or a port value. However, you can't specify both.
	ContainerPort *int32

	// The port value used if your service discovery service specified an SRV record.
	// This field might be used if both the awsvpc network mode and SRV records are
	// used.
	Port *int32

	// The Amazon Resource Name (ARN) of the service registry. The currently supported
	// service registry is Cloud Map. For more information, see CreateService (https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html)
	// .
	RegistryArn *string
	// contains filtered or unexported fields
}

type ServiceVolumeConfiguration struct {

	// The name of the volume. This value must match the volume name from the Volume
	// object in the task definition.
	//
	// This member is required.
	Name *string

	// The configuration for the Amazon EBS volume that Amazon ECS creates and manages
	// on your behalf. These settings are used to create each Amazon EBS volume, with
	// one volume created for each task in the service. The Amazon EBS volumes are
	// visible in your account in the Amazon EC2 console once they are created.
	ManagedEBSVolume *ServiceManagedEBSVolumeConfiguration
	// contains filtered or unexported fields
}

type Session struct {

	// The ID of the execute command session.
	SessionId *string

	// A URL to the managed agent on the container that the SSM Session Manager client
	// uses to send commands and receive output from the container.
	StreamUrl *string

	// An encrypted token value containing session and caller information. It's used
	// to authenticate the connection to the container.
	TokenValue *string
	// contains filtered or unexported fields
}

type Setting struct {

	// The Amazon ECS resource name.
	Name SettingName

	// The ARN of the principal. It can be a user, role, or the root user. If this
	// field is omitted, the authenticated user is assumed.
	PrincipalArn *string

	// Indicates whether Amazon Web Services manages the account setting, or if the
	// user manages it. aws_managed account settings are read-only, as Amazon Web
	// Services manages such on the customer's behalf. Currently, the guardDutyActivate
	// account setting is the only one Amazon Web Services manages.
	Type SettingType

	// Determines whether the account setting is on or off for the specified resource.
	Value *string
	// contains filtered or unexported fields
}

type SettingName string

type SettingType string

type SortOrder string

type StabilityStatus string

type SystemControl struct {

	// The namespaced kernel parameter to set a value for.
	Namespace *string

	// The namespaced kernel parameter to set a value for. Valid IPC namespace values:
	// "kernel.msgmax" | "kernel.msgmnb" | "kernel.msgmni" | "kernel.sem" |
	// "kernel.shmall" | "kernel.shmmax" | "kernel.shmmni" | "kernel.shm_rmid_forced" ,
	// and Sysctls that start with "fs.mqueue.*" Valid network namespace values:
	// Sysctls that start with "net.*" All of these values are supported by Fargate.
	Value *string
	// contains filtered or unexported fields
}

type Tag struct {

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

	// The optional part of a key-value pair that make up a tag. A value acts as a
	// descriptor within a tag category (key).
	Value *string
	// contains filtered or unexported fields
}

type TargetNotConnectedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type TargetNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type TargetType string

type Task struct {

	// The Elastic Network Adapter that's associated with the task if the task uses
	// the awsvpc network mode.
	Attachments []Attachment

	// The attributes of the task
	Attributes []Attribute

	// The Availability Zone for the task.
	AvailabilityZone *string

	// The capacity provider that's associated with the task.
	CapacityProviderName *string

	// The ARN of the cluster that hosts the task.
	ClusterArn *string

	// The connectivity status of a task.
	Connectivity Connectivity

	// The Unix timestamp for the time when the task last went into CONNECTED status.
	ConnectivityAt *time.Time

	// The ARN of the container instances that host the task.
	ContainerInstanceArn *string

	// The containers that's associated with the task.
	Containers []Container

	// The number of CPU units used by the task as expressed in a task definition. It
	// can be expressed as an integer using CPU units (for example, 1024 ). It can also
	// be expressed as a string using vCPUs (for example, 1 vCPU or 1 vcpu ). String
	// values are converted to an integer that indicates the CPU units when the task
	// definition is registered. If you use the EC2 launch type, this field is
	// optional. Supported values are between 128 CPU units ( 0.125 vCPUs) and 10240
	// CPU units ( 10 vCPUs). If you use the Fargate launch type, this field is
	// required. You must use one of the following values. These values determine the
	// range of supported values for the memory parameter: The CPU units cannot be
	// less than 1 vCPU when you use Windows containers on Fargate.
	//   - 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2
	//   GB)
	//   - 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3
	//   GB), 4096 (4 GB)
	//   - 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4
	//   GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
	//   - 2048 (2 vCPU) - Available memory values: 4096 (4 GB) and 16384 (16 GB) in
	//   increments of 1024 (1 GB)
	//   - 4096 (4 vCPU) - Available memory values: 8192 (8 GB) and 30720 (30 GB) in
	//   increments of 1024 (1 GB)
	//   - 8192 (8 vCPU) - Available memory values: 16 GB and 60 GB in 4 GB increments
	//   This option requires Linux platform 1.4.0 or later.
	//   - 16384 (16vCPU) - Available memory values: 32GB and 120 GB in 8 GB increments
	//   This option requires Linux platform 1.4.0 or later.
	Cpu *string

	// The Unix timestamp for the time when the task was created. More specifically,
	// it's for the time when the task entered the PENDING state.
	CreatedAt *time.Time

	// The desired status of the task. For more information, see Task Lifecycle (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html)
	// .
	DesiredStatus *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 ephemeral storage settings for the task.
	EphemeralStorage *EphemeralStorage

	// The Unix timestamp for the time when the task execution stopped.
	ExecutionStoppedAt *time.Time

	// The name of the task group that's associated with the task.
	Group *string

	// The health status for the task. It's determined by the health of the essential
	// containers in the task. If all essential containers in the task are reporting as
	// HEALTHY , the task status also reports as HEALTHY . If any essential containers
	// in the task are reporting as UNHEALTHY or UNKNOWN , the task status also reports
	// as UNHEALTHY or UNKNOWN . The Amazon ECS container agent doesn't monitor or
	// report on Docker health checks that are embedded in a container image and not
	// specified in the container definition. For example, this includes those
	// specified in a parent image or from the image's Dockerfile. Health check
	// parameters that are specified in a container definition override any Docker
	// health checks that are found in the container image.
	HealthStatus HealthStatus

	// The Elastic Inference accelerator that's associated with the task.
	InferenceAccelerators []InferenceAccelerator

	// The last known status for the task. For more information, see Task Lifecycle (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html)
	// .
	LastStatus *string

	// The infrastructure where your task runs on. For more information, see Amazon
	// ECS launch types (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
	// in the Amazon Elastic Container Service Developer Guide.
	LaunchType LaunchType

	// The amount of memory (in MiB) that the task uses as expressed in a task
	// definition. It can be expressed as an integer using MiB (for example, 1024 ). If
	// it's expressed as a string using GB (for example, 1GB or 1 GB ), it's converted
	// to an integer indicating the MiB when the task definition is registered. If you
	// use the EC2 launch type, this field is optional. If you use the Fargate launch
	// type, this field is required. You must use one of the following values. The
	// value that you choose determines the range of supported values for the cpu
	// parameter.
	//   - 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25
	//   vCPU)
	//   - 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values:
	//   512 (.5 vCPU)
	//   - 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7
	//   GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU)
	//   - Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) -
	//   Available cpu values: 2048 (2 vCPU)
	//   - Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) -
	//   Available cpu values: 4096 (4 vCPU)
	//   - Between 16 GB and 60 GB in 4 GB increments - Available cpu values: 8192 (8
	//   vCPU) This option requires Linux platform 1.4.0 or later.
	//   - Between 32GB and 120 GB in 8 GB increments - Available cpu values: 16384 (16
	//   vCPU) This option requires Linux platform 1.4.0 or later.
	Memory *string

	// One or more container overrides.
	Overrides *TaskOverride

	// The operating system that your tasks are running on. A platform family is
	// specified only for tasks that use the Fargate launch type. All tasks that run as
	// part of this service must use the same platformFamily value as the service (for
	// example, LINUX. ).
	PlatformFamily *string

	// The platform version where your task runs on. A platform version is only
	// specified for tasks that use the Fargate launch type. If you didn't specify one,
	// the LATEST platform version is used. For more information, see Fargate Platform
	// Versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
	// in the Amazon Elastic Container Service Developer Guide.
	PlatformVersion *string

	// The Unix timestamp for the time when the container image pull began.
	PullStartedAt *time.Time

	// The Unix timestamp for the time when the container image pull completed.
	PullStoppedAt *time.Time

	// The Unix timestamp for the time when the task started. More specifically, it's
	// for the time when the task transitioned from the PENDING state to the RUNNING
	// state.
	StartedAt *time.Time

	// The tag specified when a task is started. If an Amazon ECS service started the
	// task, the startedBy parameter contains the deployment ID of that service.
	StartedBy *string

	// The stop code indicating why a task was stopped. The stoppedReason might
	// contain additional details. For more information about stop code, see Stopped
	// tasks error codes (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/stopped-task-error-codes.html)
	// in the Amazon ECS Developer Guide.
	StopCode TaskStopCode

	// The Unix timestamp for the time when the task was stopped. More specifically,
	// it's for the time when the task transitioned from the RUNNING state to the
	// STOPPED state.
	StoppedAt *time.Time

	// The reason that the task was stopped.
	StoppedReason *string

	// The Unix timestamp for the time when the task stops. More specifically, it's
	// for the time when the task transitions from the RUNNING state to STOPPING .
	StoppingAt *time.Time

	// The metadata that you apply to the task to help you categorize and organize the
	// task. Each tag consists of a key and an optional value. You define both the key
	// and value. The following basic restrictions apply to tags:
	//   - Maximum number of tags per resource - 50
	//   - For each resource, each tag key must be unique, and each tag key can have
	//   only one value.
	//   - Maximum key length - 128 Unicode characters in UTF-8
	//   - Maximum value length - 256 Unicode characters in UTF-8
	//   - If your tagging schema is used across multiple services and resources,
	//   remember that other services may have restrictions on allowed characters.
	//   Generally allowed characters are: letters, numbers, and spaces representable in
	//   UTF-8, and the following characters: + - = . _ : / @.
	//   - Tag keys and values are case-sensitive.
	//   - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
	//   prefix for either keys or values as it is reserved for Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	Tags []Tag

	// The Amazon Resource Name (ARN) of the task.
	TaskArn *string

	// The ARN of the task definition that creates the task.
	TaskDefinitionArn *string

	// The version counter for the task. Every time a task experiences a change that
	// starts a CloudWatch event, the version counter is incremented. If you replicate
	// your Amazon ECS task state with CloudWatch Events, you can compare the version
	// of a task reported by the Amazon ECS API actions with the version reported in
	// CloudWatch Events for the task (inside the detail object) to verify that the
	// version in your event stream is current.
	Version int64
	// contains filtered or unexported fields
}