ecs

type Client struct {
	// contains filtered or unexported fields
}

type CreateCapacityProviderInput struct {
	// The details of the Auto Scaling group for the capacity provider.
	AutoScalingGroupProvider *types.AutoScalingGroupProvider
	// The name of the capacity provider. Up to 255 characters are allowed, including
	// letters (upper and lowercase), numbers, underscores, and hyphens. The name
	// cannot be prefixed with "aws", "ecs", or "fargate".
	Name *string
	// The metadata that you apply to the capacity provider to help you categorize and
	// organize them. Each tag consists of a key and an optional value, both of which
	// you define. 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 AWS 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 []*types.Tag
}

type CreateCapacityProviderOutput struct {
	// The full description of the new capacity provider.
	CapacityProvider *types.CapacityProvider

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateClusterInput struct {
	// The short name of one or more capacity providers to associate with the cluster.
	// If specifying a capacity provider that uses an Auto Scaling group, the capacity
	// provider must already be created and not already associated with another
	// cluster. New capacity providers can be created with the CreateCapacityProvider
	// () API operation. To use a AWS Fargate capacity provider, specify either the
	// FARGATE or FARGATE_SPOT capacity providers. The AWS Fargate capacity providers
	// are available to all accounts and only need to be associated with a cluster to
	// be used. The PutClusterCapacityProviders () API operation is used to update the
	// list of available capacity providers for a cluster after the cluster is created.
	CapacityProviders []*string
	// The name of your cluster. If you do not specify a name for your cluster, you
	// create a cluster named default. Up to 255 letters (uppercase and lowercase),
	// numbers, and hyphens are allowed.
	ClusterName *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, both of which you
	// define. 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 AWS 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 []*types.Tag
	// The capacity provider strategy to use by default for the cluster. When creating
	// a service or running a task on a cluster, if no capacity provider or launch type
	// is specified then the default capacity provider strategy for the cluster is
	// used. A capacity provider strategy consists of one or more capacity providers
	// along with the base and weight to assign to them. A capacity provider must be
	// associated with the cluster to be used in a capacity provider strategy. The
	// PutClusterCapacityProviders () API is used to associate a capacity provider with
	// a cluster. Only capacity providers with an ACTIVE or UPDATING status can be
	// used. If specifying a capacity provider that uses an Auto Scaling group, the
	// capacity provider must already be created. New capacity providers can be created
	// with the CreateCapacityProvider () API operation. To use a AWS Fargate capacity
	// provider, specify either the FARGATE or FARGATE_SPOT capacity providers. The AWS
	// Fargate capacity providers are available to all accounts and only need to be
	// associated with a cluster to be used. If a default capacity provider strategy is
	// not defined for a cluster during creation, it can be defined later with the
	// PutClusterCapacityProviders () API operation.
	DefaultCapacityProviderStrategy []*types.CapacityProviderStrategyItem
	// The setting to use when creating a cluster. This parameter is used to enable
	// CloudWatch Container Insights for a cluster. If this value is specified, it will
	// override the containerInsights value set with PutAccountSetting () or
	// PutAccountSettingDefault ().
	Settings []*types.ClusterSetting
}

type CreateClusterOutput struct {
	// The full description of your new cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateServiceInput struct {
	// Optional deployment parameters that control how many tasks run during the
	// deployment and the ordering of stopping and starting tasks.
	DeploymentConfiguration *types.DeploymentConfiguration
	// The family and revision (family:revision) or full ARN of the task definition to
	// run in your service. If a revision is not specified, the latest ACTIVE revision
	// is used. A task definition must be specified if the service is using the ECS
	// deployment controller.
	TaskDefinition *string
	// The name of your service. Up to 255 letters (uppercase and lowercase), numbers,
	// and hyphens are allowed. Service names must be unique within a cluster, but you
	// can have similarly named services in multiple clusters within a Region or across
	// multiple Regions.
	ServiceName *string
	// A load balancer object representing the load balancers to use with your service.
	// For more information, see Service Load Balancing
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html)
	// in the Amazon Elastic Container Service Developer Guide. If the service is using
	// the rolling update (ECS) deployment controller and using either an Application
	// Load Balancer or Network Load Balancer, you can specify multiple target groups
	// to attach to the service. The service-linked role is required for services that
	// make use of multiple target groups. For more information, see Using
	// Service-Linked Roles for Amazon ECS
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html)
	// in the Amazon Elastic Container Service Developer Guide. If the service is using
	// the CODE_DEPLOY deployment controller, the service is required to use either an
	// Application Load Balancer or Network Load Balancer. When creating an AWS
	// CodeDeploy deployment group, you specify two target groups (referred to as a
	// targetGroupPair). During a deployment, AWS CodeDeploy determines which task set
	// in your service has the status PRIMARY and associates one target group with it,
	// and then associates the other target group with the replacement task set. The
	// load balancer can also have up to two listeners: a required listener for
	// production traffic and an optional listener that allows you perform validation
	// tests with Lambda functions before routing production traffic to it. After you
	// create a service using the ECS deployment controller, the load balancer name or
	// target group ARN, container name, and container port specified in the service
	// definition are immutable. If you are using the CODE_DEPLOY deployment
	// controller, these values can be changed when updating the service. For
	// Application Load Balancers and Network Load Balancers, this object must contain
	// the load balancer target group ARN, the container name (as it appears in a
	// container definition), and the container port to access from the load balancer.
	// When a task from this service is placed on a container instance, the container
	// instance and port combination is registered as a target in the target group
	// specified here. For Classic Load Balancers, this object must contain the load
	// balancer name, the container name (as it appears in a container definition), and
	// the container port to access from the load balancer. When a task from this
	// service is placed on a container instance, the container instance is registered
	// with the load balancer specified here. Services with tasks that use the awsvpc
	// network mode (for example, those with the Fargate launch type) only support
	// Application Load Balancers and Network Load Balancers. Classic Load Balancers
	// are not supported. Also, when you create any target groups for these services,
	// you must choose ip as the target type, not instance, because tasks that use the
	// awsvpc network mode are associated with an elastic network interface, not an
	// Amazon EC2 instance.
	LoadBalancers []*types.LoadBalancer
	// The network configuration for the service. This parameter is required for task
	// definitions that use the awsvpc network mode to receive their own elastic
	// network interface, and it is not supported for other network modes. For more
	// information, see Task Networking
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html)
	// in the Amazon Elastic Container Service Developer Guide.
	NetworkConfiguration *types.NetworkConfiguration
	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request. Up to 32 ASCII characters are allowed.
	ClientToken *string
	// 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. This scheduler strategy is required if the service is using
	// the CODE_DEPLOY or EXTERNAL deployment controller types.
	//
	//     * DAEMON-The
	// daemon scheduling strategy deploys exactly one task on each active container
	// instance that 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 and will stop tasks that do not meet the placement
	// constraints. When you're using this strategy, you don't need to specify a
	// desired number of tasks, a task placement strategy, or use Service Auto Scaling
	// policies. Tasks using the Fargate launch type or the CODE_DEPLOY or EXTERNAL
	// deployment controller types don't support the DAEMON scheduling strategy.
	SchedulingStrategy types.SchedulingStrategy
	// The platform version that your tasks in the service are running on. A platform
	// version is specified only for tasks using the Fargate launch type. If one isn't
	// specified, the LATEST platform version is used by default. For more information,
	// see AWS Fargate Platform Versions
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
	// in the Amazon Elastic Container Service Developer Guide.
	PlatformVersion *string
	// An array of placement constraint objects to use for tasks in your service. You
	// can specify a maximum of 10 constraints per task (this limit includes
	// constraints in the task definition and those specified at runtime).
	PlacementConstraints []*types.PlacementConstraint
	// The short name or full Amazon Resource Name (ARN) of the cluster on which to run
	// your service. If you do not specify a cluster, the default cluster is assumed.
	Cluster *string
	// The name or full Amazon Resource Name (ARN) of the IAM role that allows Amazon
	// ECS to make calls to your load balancer on your behalf. This parameter is only
	// permitted if you are using a load balancer with your service and your task
	// definition does not use the awsvpc network mode. If you specify the role
	// parameter, you must also specify a load balancer object with the loadBalancers
	// parameter. If your account has already created the Amazon ECS service-linked
	// role, that role is used by default for your service unless you specify a role
	// here. The service-linked role is required if your task definition uses the
	// awsvpc network mode or if the service is configured to use service discovery, an
	// external deployment controller, multiple target groups, or Elastic Inference
	// accelerators in which case you should not specify a role here. For more
	// information, see Using Service-Linked Roles for Amazon ECS
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html)
	// in the Amazon Elastic Container Service Developer Guide. If your specified role
	// has a path other than /, then you must either specify the full role ARN (this is
	// recommended) or prefix the role name with the path. For example, if a role with
	// the name bar has a path of /foo/ then you would specify /foo/bar as the role
	// name. For more information, see Friendly Names and Paths
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names)
	// in the IAM User Guide.
	Role *string
	// The period of time, in seconds, that the Amazon ECS service scheduler should
	// ignore unhealthy Elastic Load Balancing target health checks after a task has
	// first started. This is only used when your service is configured to use a load
	// balancer. If your service has a load balancer defined and you don't specify a
	// health check grace period value, the default value of 0 is used. If your
	// service's tasks take a while to start and respond to Elastic Load Balancing
	// health checks, you can specify a health check grace period of up to
	// 2,147,483,647 seconds. During that time, the Amazon ECS service scheduler
	// ignores health check status. This grace period can prevent the service scheduler
	// from marking tasks as unhealthy and stopping them before they have time to come
	// up.
	HealthCheckGracePeriodSeconds *int32
	// The capacity provider strategy to use for the service. A capacity provider
	// strategy consists of one or more capacity providers along with the base and
	// weight to assign to them. A capacity provider must be associated with the
	// cluster to be used in a capacity provider strategy. The
	// PutClusterCapacityProviders () API is used to associate a capacity provider with
	// a cluster. Only capacity providers with an ACTIVE or UPDATING status can be
	// used. If a capacityProviderStrategy is specified, the launchType parameter must
	// be omitted. If no capacityProviderStrategy or launchType is specified, the
	// defaultCapacityProviderStrategy for the cluster is used. If specifying a
	// capacity provider that uses an Auto Scaling group, the capacity provider must
	// already be created. New capacity providers can be created with the
	// CreateCapacityProvider () API operation. To use a AWS Fargate capacity provider,
	// specify either the FARGATE or FARGATE_SPOT capacity providers. The AWS Fargate
	// capacity providers are available to all accounts and only need to be associated
	// with a cluster to be used. The PutClusterCapacityProviders () API operation is
	// used to update the list of available capacity providers for a cluster after the
	// cluster is created.
	CapacityProviderStrategy []*types.CapacityProviderStrategyItem
	// The launch type on which to run your service. 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. If a launchType is
	// specified, the capacityProviderStrategy parameter must be omitted.
	LaunchType types.LaunchType
	// 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, both of which you
	// define. When a service is deleted, the tags are deleted as well. 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
	// AWS 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 []*types.Tag
	// Specifies whether to enable Amazon ECS managed tags for the tasks within 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
	// The details of 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).
	// Service discovery is supported for Fargate tasks if you are using platform
	// version v1.1.0 or later. For more information, see AWS Fargate Platform Versions
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).
	ServiceRegistries []*types.ServiceRegistry
	// The deployment controller to use for the service.
	DeploymentController *types.DeploymentController
	// Specifies whether to propagate the tags from the task definition or the service
	// to the tasks in the service. If no value is specified, the tags are not
	// propagated. Tags can only be propagated to the tasks within the service during
	// service creation. To add tags to a task after service creation, use the
	// TagResource () API action.
	PropagateTags types.PropagateTags
	// The placement strategy objects to use for tasks in your service. You can specify
	// a maximum of five strategy rules per service.
	PlacementStrategy []*types.PlacementStrategy
	// The number of instantiations of the specified task definition to place and keep
	// running on your cluster. This is required if schedulingStrategy is REPLICA or is
	// not specified. If schedulingStrategy is DAEMON then this is not required.
	DesiredCount *int32
}

type CreateServiceOutput struct {
	// The full description of your service following the create call. If a service is
	// using the ECS deployment controller, the deploymentController and taskSets
	// parameters will not be returned. If the service is using the CODE_DEPLOY
	// deployment controller, the deploymentController, taskSets and deployments
	// parameters will be returned, however the deployments parameter will be an empty
	// list.
	Service *types.Service

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateTaskSetInput struct {
	// The details of the service discovery registries to assign to this task set. For
	// more information, see Service Discovery
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html).
	ServiceRegistries []*types.ServiceRegistry
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service to create the task set in.
	Cluster *string
	// The platform version that the tasks in the task set should use. A platform
	// version is specified only for tasks using the Fargate launch type. If one isn't
	// specified, the LATEST platform version is used by default.
	PlatformVersion *string
	// A load balancer object representing the load balancer to use with the task set.
	// The supported load balancer types are either an Application Load Balancer or a
	// Network Load Balancer.
	LoadBalancers []*types.LoadBalancer
	// An optional non-unique tag that identifies this task set in external systems. If
	// the task set is associated with a service discovery registry, the tasks in this
	// task set will have the ECS_TASK_SET_EXTERNAL_ID AWS Cloud Map attribute set to
	// the provided value.
	ExternalId *string
	// An object representing the network configuration for a task or service.
	NetworkConfiguration *types.NetworkConfiguration
	// The short name or full Amazon Resource Name (ARN) of the service to create the
	// task set in.
	Service *string
	// The capacity provider strategy to use for the task set. A capacity provider
	// strategy consists of one or more capacity providers along with the base and
	// weight to assign to them. A capacity provider must be associated with the
	// cluster to be used in a capacity provider strategy. The
	// PutClusterCapacityProviders () API is used to associate a capacity provider with
	// a cluster. Only capacity providers with an ACTIVE or UPDATING status can be
	// used. If a capacityProviderStrategy is specified, the launchType parameter must
	// be omitted. If no capacityProviderStrategy or launchType is specified, the
	// defaultCapacityProviderStrategy for the cluster is used. If specifying a
	// capacity provider that uses an Auto Scaling group, the capacity provider must
	// already be created. New capacity providers can be created with the
	// CreateCapacityProvider () API operation. To use a AWS Fargate capacity provider,
	// specify either the FARGATE or FARGATE_SPOT capacity providers. The AWS Fargate
	// capacity providers are available to all accounts and only need to be associated
	// with a cluster to be used. The PutClusterCapacityProviders () API operation is
	// used to update the list of available capacity providers for a cluster after the
	// cluster is created.
	CapacityProviderStrategy []*types.CapacityProviderStrategyItem
	// The task definition for the tasks in the task set to use.
	TaskDefinition *string
	// The launch type that new tasks in the task set will use. 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. If a launchType is
	// specified, the capacityProviderStrategy parameter must be omitted.
	LaunchType types.LaunchType
	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request. Up to 32 ASCII characters are allowed.
	ClientToken *string
	// The metadata that you apply to the task set to help you categorize and organize
	// them. Each tag consists of a key and an optional value, both of which you
	// define. When a service is deleted, the tags are deleted as well. 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
	// AWS 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 []*types.Tag
	// A floating-point percentage of the desired number of tasks to place and keep
	// running in the task set.
	Scale *types.Scale
}

type CreateTaskSetOutput struct {
	// Information about a set of Amazon ECS tasks in either an AWS 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.
	TaskSet *types.TaskSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteAccountSettingInput struct {
	// The ARN of the principal, which can be an IAM user, IAM role, or the root user.
	// If you specify the root user, it disables the account setting for all IAM users,
	// IAM roles, and the root user of the account unless an IAM user or role
	// explicitly overrides these settings. If this field is omitted, the setting is
	// changed only for the authenticated user.
	PrincipalArn *string
	// The resource name for which to disable the account setting. If
	// serviceLongArnFormat is specified, the ARN for your Amazon ECS services is
	// affected. If taskLongArnFormat is specified, the ARN and resource ID for your
	// Amazon ECS tasks is affected. If containerInstanceLongArnFormat is specified,
	// the ARN and resource ID for your Amazon ECS container instances is affected. If
	// awsvpcTrunking is specified, the ENI limit for your Amazon ECS container
	// instances is affected.
	Name types.SettingName
}

type DeleteAccountSettingOutput struct {
	// The account setting for the specified principal ARN.
	Setting *types.Setting

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteAttributesInput struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that contains
	// the resource to delete attributes. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string
	// The attributes to delete from your resource. You can specify up to 10 attributes
	// per request. For custom attributes, specify the attribute name and target ID,
	// but do not specify the value. If you specify the target ID using the short form,
	// you must also specify the target type.
	Attributes []*types.Attribute
}

type DeleteAttributesOutput struct {
	// A list of attribute objects that were successfully deleted from your resource.
	Attributes []*types.Attribute

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteCapacityProviderInput struct {
	// The short name or full Amazon Resource Name (ARN) of the capacity provider to
	// delete.
	CapacityProvider *string
}

type DeleteCapacityProviderOutput struct {
	// The details of a capacity provider.
	CapacityProvider *types.CapacityProvider

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteClusterInput struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster to delete.
	Cluster *string
}

type DeleteClusterOutput struct {
	// The full description of the deleted cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteServiceInput struct {
	// If true, allows you to delete a service even if it has not been scaled down to
	// zero tasks. It is only necessary to use this if the service is using the REPLICA
	// scheduling strategy.
	Force *bool
	// The name of the service to delete.
	Service *string
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service to delete. If you do not specify a cluster, the default cluster is
	// assumed.
	Cluster *string
}

type DeleteServiceOutput struct {
	// The full description of the deleted service.
	Service *types.Service

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteTaskSetInput struct {
	// The short name or full Amazon Resource Name (ARN) of the service that hosts the
	// task set to delete.
	Service *string
	// The task set ID or full Amazon Resource Name (ARN) of the task set to delete.
	TaskSet *string
	// If true, this allows you to delete a task set even if it hasn't been scaled down
	// to zero.
	Force *bool
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task set exists in to delete.
	Cluster *string
}

type DeleteTaskSetOutput struct {
	// Information about a set of Amazon ECS tasks in either an AWS 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.
	TaskSet *types.TaskSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeregisterContainerInstanceInput struct {
	// The container instance ID or full ARN of the container instance to deregister.
	// The ARN contains the arn:aws:ecs namespace, followed by the Region of the
	// container instance, the AWS account ID of the container instance owner, the
	// container-instance namespace, and then the container instance ID. For example,
	// arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID.
	ContainerInstance *string
	// Forces the deregistration of the container instance. If you have tasks running
	// on the container instance when you deregister it with the force option, these
	// tasks remain running until you terminate the instance or the tasks stop through
	// some other means, but they are orphaned (no longer monitored or accounted for by
	// Amazon ECS). If an orphaned task on your container instance is part of an Amazon
	// ECS service, then the service scheduler starts another copy of that task, on a
	// different container instance if possible. Any containers in orphaned service
	// tasks that are registered with a Classic Load Balancer or an Application Load
	// Balancer target group are deregistered. They begin connection draining according
	// to the settings on the load balancer or target group.
	Force *bool
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// container instance to deregister. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string
}

type DeregisterContainerInstanceOutput struct {
	// The container instance that was deregistered.
	ContainerInstance *types.ContainerInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeregisterTaskDefinitionInput struct {
	// The family and revision (family:revision) or full Amazon Resource Name (ARN) of
	// the task definition to deregister. You must specify a revision.
	TaskDefinition *string
}

type DeregisterTaskDefinitionOutput struct {
	// The full description of the deregistered task.
	TaskDefinition *types.TaskDefinition

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCapacityProvidersInput struct {
	// The nextToken value returned from a previous paginated DescribeCapacityProviders
	// request where maxResults was used and the results exceeded the value of that
	// parameter. Pagination continues from the end of the previous results that
	// returned the nextToken value. This token should be treated as an opaque
	// identifier that is only used to retrieve the next items in a list and not for
	// other programmatic purposes.
	NextToken *string
	// Specifies whether or not you want to see the resource tags for the capacity
	// provider. If TAGS is specified, the tags are included in the response. If this
	// field is omitted, tags are not included in the response.
	Include []types.CapacityProviderField
	// The maximum number of account setting results returned by
	// DescribeCapacityProviders in paginated output. When this parameter is used,
	// DescribeCapacityProviders only returns maxResults results in a single page along
	// with a nextToken response element. The remaining results of the initial request
	// can be seen by sending another DescribeCapacityProviders request with the
	// returned nextToken value. This value can be between 1 and 10. If this parameter
	// is not used, then DescribeCapacityProviders returns up to 10 results and a
	// nextToken value if applicable.
	MaxResults *int32
	// The short name or full Amazon Resource Name (ARN) of one or more capacity
	// providers. Up to 100 capacity providers can be described in an action.
	CapacityProviders []*string
}

type DescribeCapacityProvidersOutput struct {
	// Any failures associated with the call.
	Failures []*types.Failure
	// The list of capacity providers.
	CapacityProviders []*types.CapacityProvider
	// The nextToken value to include in a future DescribeCapacityProviders request.
	// When the results of a DescribeCapacityProviders request exceed maxResults, this
	// value can be used to retrieve the next page of results. This value is null when
	// there are no more results to return.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeClustersInput struct {
	// Whether to include additional information about your clusters in the response.
	// If this field is omitted, the attachments, statistics, and tags are not
	// included. If ATTACHMENTS is specified, the attachments for the container
	// instances or tasks within the cluster are included. If SETTINGS is specified,
	// the settings for the cluster are included. If STATISTICS is specified, the
	// following additional information, separated by launch type, is included:
	//
	//     *
	// runningEC2TasksCount
	//
	//     * runningFargateTasksCount
	//
	//     *
	// pendingEC2TasksCount
	//
	//     * pendingFargateTasksCount
	//
	//     *
	// activeEC2ServiceCount
	//
	//     * activeFargateServiceCount
	//
	//     *
	// drainingEC2ServiceCount
	//
	//     * drainingFargateServiceCount
	//
	// If TAGS is
	// specified, the metadata tags associated with the cluster are included.
	Include []types.ClusterField
	// A list of up to 100 cluster names or full cluster Amazon Resource Name (ARN)
	// entries. If you do not specify a cluster, the default cluster is assumed.
	Clusters []*string
}

type DescribeClustersOutput struct {
	// Any failures associated with the call.
	Failures []*types.Failure
	// The list of clusters.
	Clusters []*types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeContainerInstancesInput struct {
	// Specifies whether you want to see the resource tags for the container instance.
	// If TAGS is specified, the tags are included in the response. If this field is
	// omitted, tags are not included in the response.
	Include []types.ContainerInstanceField
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// container instances to describe. If you do not specify a cluster, the default
	// cluster is assumed. This parameter is required if the container instance or
	// container instances you are describing were launched in any cluster other than
	// the default cluster.
	Cluster *string
	// A list of up to 100 container instance IDs or full Amazon Resource Name (ARN)
	// entries.
	ContainerInstances []*string
}

type DescribeContainerInstancesOutput struct {
	// Any failures associated with the call.
	Failures []*types.Failure
	// The list of container instances.
	ContainerInstances []*types.ContainerInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeServicesInput struct {
	// A list of services to describe. You may specify up to 10 services to describe in
	// a single operation.
	Services []*string
	// Specifies whether you want to see the resource tags for the service. If TAGS is
	// specified, the tags are included in the response. If this field is omitted, tags
	// are not included in the response.
	Include []types.ServiceField
	// The short name or full Amazon Resource Name (ARN)the cluster that hosts the
	// service to describe. If you do not specify a cluster, the default cluster is
	// assumed. This parameter is required if the service or services you are
	// describing were launched in any cluster other than the default cluster.
	Cluster *string
}

type DescribeServicesOutput struct {
	// Any failures associated with the call.
	Failures []*types.Failure
	// The list of services described.
	Services []*types.Service

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeTaskDefinitionInput struct {
	// The family for the latest ACTIVE revision, family and revision (family:revision)
	// for a specific revision in the family, or full Amazon Resource Name (ARN) of the
	// task definition to describe.
	TaskDefinition *string
	// Specifies whether to see the resource tags for the task definition. If TAGS is
	// specified, the tags are included in the response. If this field is omitted, tags
	// are not included in the response.
	Include []types.TaskDefinitionField
}

type DescribeTaskDefinitionOutput struct {
	// The full task definition description.
	TaskDefinition *types.TaskDefinition
	// The metadata that is applied to the task definition to help you categorize and
	// organize them. Each tag consists of a key and an optional value, both of which
	// you define. 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 AWS 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 []*types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeTaskSetsInput struct {
	// The short name or full Amazon Resource Name (ARN) of the service that the task
	// sets exist in.
	Service *string
	// Specifies whether to see the resource tags for the task set. If TAGS is
	// specified, the tags are included in the response. If this field is omitted, tags
	// are not included in the response.
	Include []types.TaskSetField
	// The ID or full Amazon Resource Name (ARN) of task sets to describe.
	TaskSets []*string
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task sets exist in.
	Cluster *string
}

type DescribeTaskSetsOutput struct {
	// The list of task sets described.
	TaskSets []*types.TaskSet
	// Any failures associated with the call.
	Failures []*types.Failure

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeTasksInput struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// task or tasks to describe. If you do not specify a cluster, the default cluster
	// is assumed. This parameter is required if the task or tasks you are describing
	// were launched in any cluster other than the default cluster.
	Cluster *string
	// A list of up to 100 task IDs or full ARN entries.
	Tasks []*string
	// Specifies whether you want to see the resource tags for the task. If TAGS is
	// specified, the tags are included in the response. If this field is omitted, tags
	// are not included in the response.
	Include []types.TaskField
}

type DescribeTasksOutput struct {
	// The list of tasks.
	Tasks []*types.Task
	// Any failures associated with the call.
	Failures []*types.Failure

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DiscoverPollEndpointInput struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster to which the
	// container instance belongs.
	Cluster *string
	// The container instance ID or full ARN of the container instance. The ARN
	// contains the arn:aws:ecs namespace, followed by the Region of the container
	// instance, the AWS account ID of the container instance owner, the
	// container-instance namespace, and then the container instance ID. For example,
	// arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID.
	ContainerInstance *string
}

type DiscoverPollEndpointOutput struct {
	// The endpoint for the Amazon ECS agent to poll.
	Endpoint *string
	// The telemetry endpoint for the Amazon ECS agent.
	TelemetryEndpoint *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options ResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options ResolverOptions) (aws.Endpoint, error)

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type ListAccountSettingsInput struct {
	// The maximum number of account setting results returned by ListAccountSettings in
	// paginated output. When this parameter is used, ListAccountSettings only returns
	// maxResults results in a single page along with a nextToken response element. The
	// remaining results of the initial request can be seen by sending another
	// ListAccountSettings request with the returned nextToken value. This value can be
	// between 1 and 10. If this parameter is not used, then ListAccountSettings
	// returns up to 10 results and a nextToken value if applicable.
	MaxResults *int32
	// The ARN of the principal, which can be an IAM user, IAM role, or the root user.
	// If this field is omitted, the account settings are listed only for the
	// authenticated user.
	PrincipalArn *string
	// The nextToken value returned from a ListAccountSettings request indicating that
	// more results are available to fulfill the request and further calls will be
	// needed. If maxResults was provided, it is possible the number of results to be
	// fewer than maxResults. This token should be treated as an opaque identifier that
	// is only used to retrieve the next items in a list and not for other programmatic
	// purposes.
	NextToken *string
	// The value of the account settings with which to filter results. You must also
	// specify an account setting name to use this parameter.
	Value *string
	// The name of the account setting you want to list the settings for.
	Name types.SettingName
	// Specifies whether to return the effective settings. If true, the account
	// settings for the root user or the default setting for the principalArn are
	// returned. If false, the account settings for the principalArn are returned if
	// they are set. Otherwise, no account settings are returned.
	EffectiveSettings *bool
}

type ListAccountSettingsOutput struct {
	// The account settings for the resource.
	Settings []*types.Setting
	// The nextToken value to include in a future ListAccountSettings request. When the
	// results of a ListAccountSettings request exceed maxResults, this value can be
	// used to retrieve the next page of results. This value is null when there are no
	// more results to return.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListAttributesInput struct {
	// The maximum number of cluster results returned by ListAttributes in paginated
	// output. When this parameter is used, ListAttributes only returns maxResults
	// results in a single page along with a nextToken response element. The remaining
	// results of the initial request can be seen by sending another ListAttributes
	// request with the returned nextToken value. This value can be between 1 and 100.
	// If this parameter is not used, then ListAttributes returns up to 100 results and
	// a nextToken value if applicable.
	MaxResults *int32
	// The nextToken value returned from a ListAttributes request indicating that more
	// results are available to fulfill the request and further calls will be needed.
	// If maxResults was provided, it is possible the number of results to be fewer
	// than maxResults. This token should be treated as an opaque identifier that is
	// only used to retrieve the next items in a list and not for other programmatic
	// purposes.
	NextToken *string
	// The short name or full Amazon Resource Name (ARN) of the cluster to list
	// attributes. If you do not specify a cluster, the default cluster is assumed.
	Cluster *string
	// The name of the attribute with which to filter the results.
	AttributeName *string
	// The value of the attribute with which to filter results. You must also specify
	// an attribute name to use this parameter.
	AttributeValue *string
	// The type of the target with which to list attributes.
	TargetType types.TargetType
}

type ListAttributesOutput struct {
	// The nextToken value to include in a future ListAttributes request. When the
	// results of a ListAttributes request exceed maxResults, this value can be used to
	// retrieve the next page of results. This value is null when there are no more
	// results to return.
	NextToken *string
	// A list of attribute objects that meet the criteria of the request.
	Attributes []*types.Attribute

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListClustersInput struct {
	// The maximum number of cluster results returned by ListClusters in paginated
	// output. When this parameter is used, ListClusters only returns maxResults
	// results in a single page along with a nextToken response element. The remaining
	// results of the initial request can be seen by sending another ListClusters
	// request with the returned nextToken value. This value can be between 1 and 100.
	// If this parameter is not used, then ListClusters returns up to 100 results and a
	// nextToken value if applicable.
	MaxResults *int32
	// The nextToken value returned from a ListClusters request indicating that more
	// results are available to fulfill the request and further calls will be needed.
	// If maxResults was provided, it is possible the number of results to be fewer
	// than maxResults. This token should be treated as an opaque identifier that is
	// only used to retrieve the next items in a list and not for other programmatic
	// purposes.
	NextToken *string
}

type ListClustersOutput struct {
	// The list of full Amazon Resource Name (ARN) entries for each cluster associated
	// with your account.
	ClusterArns []*string
	// The nextToken value to include in a future ListClusters request. When the
	// results of a ListClusters request exceed maxResults, this value can be used to
	// retrieve the next page of results. This value is null when there are no more
	// results to return.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListContainerInstancesInput struct {
	// Filters the container instances by status. For example, if you specify the
	// DRAINING status, the results include only container instances that have been set
	// to DRAINING using UpdateContainerInstancesState (). If you do not specify this
	// parameter, the default is to include container instances set to all states other
	// than INACTIVE.
	Status types.ContainerInstanceStatus
	// You can filter the results of a ListContainerInstances operation with cluster
	// query language statements. 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.
	Filter *string
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// container instances to list. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string
	// The maximum number of container instance results returned by
	// ListContainerInstances in paginated output. When this parameter is used,
	// ListContainerInstances only returns maxResults results in a single page along
	// with a nextToken response element. The remaining results of the initial request
	// can be seen by sending another ListContainerInstances request with the returned
	// nextToken value. This value can be between 1 and 100. If this parameter is not
	// used, then ListContainerInstances returns up to 100 results and a nextToken
	// value if applicable.
	MaxResults *int32
	// The nextToken value returned from a ListContainerInstances request indicating
	// that more results are available to fulfill the request and further calls will be
	// needed. If maxResults was provided, it is possible the number of results to be
	// fewer than maxResults. This token should be treated as an opaque identifier that
	// is only used to retrieve the next items in a list and not for other programmatic
	// purposes.
	NextToken *string
}

type ListContainerInstancesOutput struct {
	// The nextToken value to include in a future ListContainerInstances request. When
	// the results of a ListContainerInstances request exceed maxResults, this value
	// can be used to retrieve the next page of results. This value is null when there
	// are no more results to return.
	NextToken *string
	// The list of container instances with full ARN entries for each container
	// instance associated with the specified cluster.
	ContainerInstanceArns []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListServicesInput struct {
	// The maximum number of service results returned by ListServices in paginated
	// output. When this parameter is used, ListServices only returns maxResults
	// results in a single page along with a nextToken response element. The remaining
	// results of the initial request can be seen by sending another ListServices
	// request with the returned nextToken value. This value can be between 1 and 100.
	// If this parameter is not used, then ListServices returns up to 10 results and a
	// nextToken value if applicable.
	MaxResults *int32
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// services to list. If you do not specify a cluster, the default cluster is
	// assumed.
	Cluster *string
	// The nextToken value returned from a ListServices request indicating that more
	// results are available to fulfill the request and further calls will be needed.
	// If maxResults was provided, it is possible the number of results to be fewer
	// than maxResults. This token should be treated as an opaque identifier that is
	// only used to retrieve the next items in a list and not for other programmatic
	// purposes.
	NextToken *string
	// The scheduling strategy for services to list.
	SchedulingStrategy types.SchedulingStrategy
	// The launch type for the services to list.
	LaunchType types.LaunchType
}

type ListServicesOutput struct {
	// The nextToken value to include in a future ListServices request. When the
	// results of a ListServices request exceed maxResults, this value can be used to
	// retrieve the next page of results. This value is null when there are no more
	// results to return.
	NextToken *string
	// The list of full ARN entries for each service associated with the specified
	// cluster.
	ServiceArns []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTagsForResourceInput struct {
	// The Amazon Resource Name (ARN) that identifies the resource for which to list
	// the tags. Currently, the supported resources are Amazon ECS tasks, services,
	// task definitions, clusters, and container instances.
	ResourceArn *string
}

type ListTagsForResourceOutput struct {
	// The tags for the resource.
	Tags []*types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTaskDefinitionFamiliesInput struct {
	// The nextToken value returned from a ListTaskDefinitionFamilies request
	// indicating that more results are available to fulfill the request and further
	// calls will be needed. If maxResults was provided, it is possible the number of
	// results to be fewer than maxResults. This token should be treated as an opaque
	// identifier that is only used to retrieve the next items in a list and not for
	// other programmatic purposes.
	NextToken *string
	// The familyPrefix is a string that is used to filter the results of
	// ListTaskDefinitionFamilies. If you specify a familyPrefix, only task definition
	// family names that begin with the familyPrefix string are returned.
	FamilyPrefix *string
	// The maximum number of task definition family results returned by
	// ListTaskDefinitionFamilies in paginated output. When this parameter is used,
	// ListTaskDefinitions only returns maxResults results in a single page along with
	// a nextToken response element. The remaining results of the initial request can
	// be seen by sending another ListTaskDefinitionFamilies request with the returned
	// nextToken value. This value can be between 1 and 100. If this parameter is not
	// used, then ListTaskDefinitionFamilies returns up to 100 results and a nextToken
	// value if applicable.
	MaxResults *int32
	// The task definition family status with which to filter the
	// ListTaskDefinitionFamilies results. By default, both ACTIVE and INACTIVE task
	// definition families are listed. If this parameter is set to ACTIVE, only task
	// definition families that have an ACTIVE task definition revision are returned.
	// If this parameter is set to INACTIVE, only task definition families that do not
	// have any ACTIVE task definition revisions are returned. If you paginate the
	// resulting output, be sure to keep the status value constant in each subsequent
	// request.
	Status types.TaskDefinitionFamilyStatus
}

type ListTaskDefinitionFamiliesOutput struct {
	// The nextToken value to include in a future ListTaskDefinitionFamilies request.
	// When the results of a ListTaskDefinitionFamilies request exceed maxResults, this
	// value can be used to retrieve the next page of results. This value is null when
	// there are no more results to return.
	NextToken *string
	// The list of task definition family names that match the
	// ListTaskDefinitionFamilies request.
	Families []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTaskDefinitionsInput struct {
	// The nextToken value returned from a ListTaskDefinitions request indicating that
	// more results are available to fulfill the request and further calls will be
	// needed. If maxResults was provided, it is possible the number of results to be
	// fewer than maxResults. This token should be treated as an opaque identifier that
	// is only used to retrieve the next items in a list and not for other programmatic
	// purposes.
	NextToken *string
	// The order in which to sort the results. Valid values are ASC and DESC. By
	// default (ASC), task definitions are listed lexicographically by family name and
	// in ascending numerical order by revision so that the newest task definitions in
	// a family are listed last. Setting this parameter to DESC reverses the sort order
	// on family name and revision so that the newest task definitions in a family are
	// listed first.
	Sort types.SortOrder
	// The task definition status with which to filter the ListTaskDefinitions results.
	// By default, only ACTIVE task definitions are listed. By setting this parameter
	// to INACTIVE, you can view task definitions that are INACTIVE as long as an
	// active task or service still references them. If you paginate the resulting
	// output, be sure to keep the status value constant in each subsequent request.
	Status types.TaskDefinitionStatus
	// The maximum number of task definition results returned by ListTaskDefinitions in
	// paginated output. When this parameter is used, ListTaskDefinitions only returns
	// maxResults results in a single page along with a nextToken response element. The
	// remaining results of the initial request can be seen by sending another
	// ListTaskDefinitions request with the returned nextToken value. This value can be
	// between 1 and 100. If this parameter is not used, then ListTaskDefinitions
	// returns up to 100 results and a nextToken value if applicable.
	MaxResults *int32
	// The full family name with which to filter the ListTaskDefinitions results.
	// Specifying a familyPrefix limits the listed task definitions to task definition
	// revisions that belong to that family.
	FamilyPrefix *string
}

type ListTaskDefinitionsOutput struct {
	// The list of task definition Amazon Resource Name (ARN) entries for the
	// ListTaskDefinitions request.
	TaskDefinitionArns []*string
	// The nextToken value to include in a future ListTaskDefinitions request. When the
	// results of a ListTaskDefinitions request exceed maxResults, this value can be
	// used to retrieve the next page of results. This value is null when there are no
	// more results to return.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTasksInput struct {
	// The startedBy value with which to filter the task results. Specifying a
	// startedBy value limits the results to tasks that were started with that value.
	StartedBy *string
	// The container instance ID or full ARN of the container instance with which to
	// filter the ListTasks results. Specifying a containerInstance limits the results
	// to tasks that belong to that container instance.
	ContainerInstance *string
	// The maximum number of task results returned by ListTasks in paginated output.
	// When this parameter is used, ListTasks only returns maxResults results in a
	// single page along with a nextToken response element. The remaining results of
	// the initial request can be seen by sending another ListTasks request with the
	// returned nextToken value. This value can be between 1 and 100. If this parameter
	// is not used, then ListTasks returns up to 100 results and a nextToken value if
	// applicable.
	MaxResults *int32
	// The nextToken value returned from a ListTasks request indicating that more
	// results are available to fulfill the request and further calls will be needed.
	// If maxResults was provided, it is possible the number of results to be fewer
	// than maxResults. This token should be treated as an opaque identifier that is
	// only used to retrieve the next items in a list and not for other programmatic
	// purposes.
	NextToken *string
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// tasks to list. If you do not specify a cluster, the default cluster is assumed.
	Cluster *string
	// The launch type for services to list.
	LaunchType types.LaunchType
	// The name of the family with which to filter the ListTasks results. Specifying a
	// family limits the results to tasks that belong to that family.
	Family *string
	// The name of the service with which to filter the ListTasks results. Specifying a
	// serviceName limits the results to tasks that belong to that service.
	ServiceName *string
	// The task desired status with which to filter the ListTasks results. Specifying a
	// desiredStatus of STOPPED limits the results to tasks that Amazon ECS has set the
	// desired status to STOPPED. This can be useful for debugging tasks that are not
	// starting properly or have died or finished. The default status filter is
	// RUNNING, which shows tasks that Amazon ECS has set the desired status to
	// RUNNING. Although you can filter results based on a desired status of PENDING,
	// this does not return any results. Amazon ECS never sets the desired status of a
	// task to that value (only a task's lastStatus may have a value of PENDING).
	DesiredStatus types.DesiredStatus
}

type ListTasksOutput struct {
	// The list of task ARN entries for the ListTasks request.
	TaskArns []*string
	// The nextToken value to include in a future ListTasks request. When the results
	// of a ListTasks request exceed maxResults, this value can be used to retrieve the
	// next page of results. This value is null when there are no more results to
	// return.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type PutAccountSettingDefaultInput struct {
	// The resource name for which to modify the account setting. If
	// serviceLongArnFormat is specified, the ARN for your Amazon ECS services is
	// affected. If taskLongArnFormat is specified, the ARN and resource ID for your
	// Amazon ECS tasks is affected. If containerInstanceLongArnFormat is specified,
	// the ARN and resource ID for your Amazon ECS container instances is affected. If
	// awsvpcTrunking is specified, the ENI limit for your Amazon ECS container
	// instances is affected. If containerInsights is specified, the default setting
	// for CloudWatch Container Insights for your clusters is affected.
	Name types.SettingName
	// The account setting value for the specified principal ARN. Accepted values are
	// enabled and disabled.
	Value *string
}

type PutAccountSettingDefaultOutput struct {
	// The current account setting for a resource.
	Setting *types.Setting

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutAccountSettingInput struct {
	// The ARN of the principal, which can be an IAM user, IAM role, or the root user.
	// If you specify the root user, it modifies the account setting for all IAM users,
	// IAM roles, and the root user of the account unless an IAM user or role
	// explicitly overrides these settings. If this field is omitted, the setting is
	// changed only for the authenticated user.
	PrincipalArn *string
	// The account setting value for the specified principal ARN. Accepted values are
	// enabled and disabled.
	Value *string
	// The Amazon ECS resource name for which to modify the account setting. If
	// serviceLongArnFormat is specified, the ARN for your Amazon ECS services is
	// affected. If taskLongArnFormat is specified, the ARN and resource ID for your
	// Amazon ECS tasks is affected. If containerInstanceLongArnFormat is specified,
	// the ARN and resource ID for your Amazon ECS container instances is affected. If
	// awsvpcTrunking is specified, the elastic network interface (ENI) limit for your
	// Amazon ECS container instances is affected. If containerInsights is specified,
	// the default setting for CloudWatch Container Insights for your clusters is
	// affected.
	Name types.SettingName
}

type PutAccountSettingOutput struct {
	// The current account setting for a resource.
	Setting *types.Setting

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutAttributesInput struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that contains
	// the resource to apply attributes. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string
	// The attributes to apply to your resource. You can specify up to 10 custom
	// attributes per resource. You can specify up to 10 attributes in a single call.
	Attributes []*types.Attribute
}

type PutAttributesOutput struct {
	// The attributes applied to your resource.
	Attributes []*types.Attribute

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutClusterCapacityProvidersInput struct {
	// The capacity provider strategy to use by default for the cluster. When creating
	// a service or running a task on a cluster, if no capacity provider or launch type
	// is specified then the default capacity provider strategy for the cluster is
	// used. A capacity provider strategy consists of one or more capacity providers
	// along with the base and weight to assign to them. A capacity provider must be
	// associated with the cluster to be used in a capacity provider strategy. The
	// PutClusterCapacityProviders () API is used to associate a capacity provider with
	// a cluster. Only capacity providers with an ACTIVE or UPDATING status can be
	// used. If specifying a capacity provider that uses an Auto Scaling group, the
	// capacity provider must already be created. New capacity providers can be created
	// with the CreateCapacityProvider () API operation. To use a AWS Fargate capacity
	// provider, specify either the FARGATE or FARGATE_SPOT capacity providers. The AWS
	// Fargate capacity providers are available to all accounts and only need to be
	// associated with a cluster to be used.
	DefaultCapacityProviderStrategy []*types.CapacityProviderStrategyItem
	// The name of one or more capacity providers to associate with the cluster. If
	// specifying a capacity provider that uses an Auto Scaling group, the capacity
	// provider must already be created. New capacity providers can be created with the
	// CreateCapacityProvider () API operation. To use a AWS Fargate capacity provider,
	// specify either the FARGATE or FARGATE_SPOT capacity providers. The AWS Fargate
	// capacity providers are available to all accounts and only need to be associated
	// with a cluster to be used.
	CapacityProviders []*string
	// The short name or full Amazon Resource Name (ARN) of the cluster to modify the
	// capacity provider settings for. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string
}

type PutClusterCapacityProvidersOutput struct {
	// A regional grouping of one or more container instances on which you can run task
	// requests. Each account receives a default cluster the first time you use the
	// Amazon ECS service, but you may also create other clusters. Clusters may contain
	// more than one instance type simultaneously.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RegisterContainerInstanceInput struct {
	// The ARN of the container instance (if it was previously registered).
	ContainerInstanceArn *string
	// The container instance attributes that this container instance supports.
	Attributes []*types.Attribute
	// The version information for the Amazon ECS container agent and Docker daemon
	// running on the container instance.
	VersionInfo *types.VersionInfo
	// The short name or full Amazon Resource Name (ARN) of the cluster with which to
	// register your container instance. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string
	// The devices that are available on the container instance. The only supported
	// device type is a GPU.
	PlatformDevices []*types.PlatformDevice
	// The instance identity document for the EC2 instance to register. This document
	// can be found by running the following command from the instance: curl
	// http://169.254.169.254/latest/dynamic/instance-identity/document/
	InstanceIdentityDocument *string
	// The instance identity document signature for the EC2 instance to register. This
	// signature can be found by running the following command from the instance: curl
	// http://169.254.169.254/latest/dynamic/instance-identity/signature/
	InstanceIdentityDocumentSignature *string
	// The resources available on the instance.
	TotalResources []*types.Resource
	// 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, both of which
	// you define. 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 AWS 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 []*types.Tag
}

type RegisterContainerInstanceOutput struct {
	// The container instance that was registered.
	ContainerInstance *types.ContainerInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RegisterTaskDefinitionInput struct {
	// The process namespace to use for the containers in the task. The valid values
	// are host or task. If host is specified, then all containers within the tasks
	// that specified the host PID mode on the same container instance share the same
	// process namespace with the host Amazon EC2 instance. If task is specified, all
	// containers within the specified task share the same process namespace. If no
	// value is specified, the default is a private namespace. For more information,
	// see PID settings
	// (https://docs.docker.com/engine/reference/run/#pid-settings---pid) in the Docker
	// run reference. If the host PID mode is used, be aware that there is a heightened
	// risk of undesired process namespace expose. For more information, see Docker
	// security (https://docs.docker.com/engine/security/security/). This parameter is
	// not supported for Windows containers or tasks using the Fargate launch type.
	PidMode types.PidMode
	// The metadata that you apply to the task definition to help you categorize and
	// organize them. Each tag consists of a key and an optional value, both of which
	// you define. 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 AWS 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 []*types.Tag
	// The launch type required by the task. If no value is specified, it defaults to
	// EC2.
	RequiresCompatibilities []types.Compatibility
	// The amount of memory (in MiB) used by the task. It can be expressed as an
	// integer using MiB, for example 1024, or as a string using GB, for example 1GB or
	// 1 GB, in a task definition. String values are converted to an integer indicating
	// the MiB when the task definition is registered. Task-level CPU and memory
	// parameters are ignored for Windows containers. We recommend specifying
	// container-level resources for Windows containers. If using the EC2 launch type,
	// this field is optional. If using the Fargate launch type, this field is required
	// and you must use one of the following values, which determines your 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)
	Memory *string
	// An array of placement constraint objects to use for the task. You can specify a
	// maximum of 10 constraints per task (this limit includes constraints in the task
	// definition and those specified at runtime).
	PlacementConstraints []*types.TaskDefinitionPlacementConstraint
	// The Docker networking mode to use for the containers in the task. The valid
	// values are none, bridge, awsvpc, and host. The default Docker network mode is
	// bridge. If you are using the Fargate launch type, the awsvpc network mode is
	// required. If you are using the EC2 launch type, any network mode can be used. If
	// the network mode is set to none, you cannot specify port mappings in your
	// container definitions, and the tasks containers do not have external
	// connectivity. The host and awsvpc network modes offer the highest networking
	// performance for containers because they use the EC2 network stack instead of the
	// virtualized network stack provided by the bridge mode. With the host and awsvpc
	// network modes, exposed container ports are mapped directly to the corresponding
	// host port (for the host network mode) or the attached elastic network interface
	// port (for the awsvpc network mode), so you cannot take advantage of dynamic host
	// port mappings. If the network mode is awsvpc, the task is allocated an elastic
	// network interface, and you must specify a NetworkConfiguration () value when you
	// create a service or run a task with the task definition. For more information,
	// see Task Networking
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html)
	// in the Amazon Elastic Container Service Developer Guide. Currently, only Amazon
	// ECS-optimized AMIs, other Amazon Linux variants with the ecs-init package, or
	// AWS Fargate infrastructure support the awsvpc network mode. If the network mode
	// is host, you cannot run multiple instantiations of the same task on a single
	// container instance when port mappings are used. Docker for Windows uses
	// different network modes than Docker for Linux. When you register a task
	// definition with Windows containers, you must not specify a network mode. If you
	// use the console to register a task definition with Windows containers, you must
	// choose the  network mode object. For more information, see Network settings
	// (https://docs.docker.com/engine/reference/run/#network-settings) in the Docker
	// run reference.
	NetworkMode types.NetworkMode
	// A list of container definitions in JSON format that describe the different
	// containers that make up your task.
	ContainerDefinitions []*types.ContainerDefinition
	// The IPC resource namespace to use for the containers in the task. The valid
	// values are host, task, or none. If host is specified, then all containers within
	// the tasks that specified the host IPC mode on the same container instance share
	// the same IPC resources with the host Amazon EC2 instance. If task is specified,
	// all containers within the specified task share the same IPC resources. If none
	// is specified, then IPC resources within the containers of a task are private and
	// not shared with other containers in a task or on the container instance. If no
	// value is specified, then the IPC resource namespace sharing depends on the
	// Docker daemon setting on the container instance. For more information, see IPC
	// settings (https://docs.docker.com/engine/reference/run/#ipc-settings---ipc) in
	// the Docker run reference. If the host IPC mode is used, be aware that there is a
	// heightened risk of undesired IPC namespace expose. For more information, see
	// Docker security (https://docs.docker.com/engine/security/security/). If you are
	// setting namespaced kernel parameters using systemControls for the containers in
	// the task, the following will apply to your IPC resource namespace. For more
	// information, see System Controls
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	//     * For tasks that
	// use the host IPC mode, IPC namespace related systemControls are not supported.
	//
	//
	// * For tasks that use the task IPC mode, IPC namespace related systemControls
	// will apply to all containers within a task.
	//
	// This parameter is not supported for
	// Windows containers or tasks using the Fargate launch type.
	IpcMode types.IpcMode
	// The Elastic Inference accelerators to use for the containers in the task.
	InferenceAccelerators []*types.InferenceAccelerator
	// A list of volume definitions in JSON format that containers in your task may
	// use.
	Volumes []*types.Volume
	// The Amazon Resource Name (ARN) of the task execution role that grants the Amazon
	// ECS container agent permission to make AWS API calls on your behalf. The task
	// execution IAM role is required depending on the requirements of your task. For
	// more information, see Amazon ECS task execution IAM role
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ExecutionRoleArn *string
	// The number of CPU units used by the task. It can be expressed as an integer
	// using CPU units, for example 1024, or as a string using vCPUs, for example 1
	// vCPU or 1 vcpu, in a task definition. String values are converted to an integer
	// indicating the CPU units when the task definition is registered. Task-level CPU
	// and memory parameters are ignored for Windows containers. We recommend
	// specifying container-level resources for Windows containers. If you are using
	// 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 are using the
	// Fargate launch type, this field is required and you must use one of the
	// following values, which determines your range of supported values for the memory
	// parameter:
	//
	//     * 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: Between 4096 (4
	// GB) and 16384 (16 GB) in increments of 1024 (1 GB)
	//
	//     * 4096 (4 vCPU) -
	// Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of
	// 1024 (1 GB)
	Cpu *string
	// The configuration details for the App Mesh proxy. For tasks using the EC2 launch
	// type, the container instances require at least version 1.26.0 of the container
	// agent and at least version 1.26.0-1 of the ecs-init package to enable a proxy
	// configuration. If your container instances are launched from the Amazon
	// ECS-optimized AMI 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 platform version 1.3.0 or
	// later.
	ProxyConfiguration *types.ProxyConfiguration
	// The short name or full Amazon Resource Name (ARN) of the IAM role that
	// containers in this task can assume. All containers in this task are granted the
	// permissions that are specified in this role. For more information, see IAM Roles
	// for Tasks
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)
	// in the Amazon Elastic Container Service Developer Guide.
	TaskRoleArn *string
	// You must specify a family for a task definition, which allows you to track
	// multiple versions of the same task definition. The family is used as a name for
	// your task definition. Up to 255 letters (uppercase and lowercase), numbers, and
	// hyphens are allowed.
	Family *string
}

type RegisterTaskDefinitionOutput struct {
	// The list of tags associated with the task definition.
	Tags []*types.Tag
	// The full description of the registered task definition.
	TaskDefinition *types.TaskDefinition

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type RunTaskInput struct {
	// The placement strategy objects to use for the task. You can specify a maximum of
	// five strategy rules per task.
	PlacementStrategy []*types.PlacementStrategy
	// Specifies whether to enable Amazon ECS managed tags for the task. 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
	// The metadata that you apply to the task to help you categorize and organize
	// them. Each tag consists of a key and an optional value, both of which you
	// define. 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 AWS 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 []*types.Tag
	// The capacity provider strategy to use for the task. A capacity provider strategy
	// consists of one or more capacity providers along with the base and weight to
	// assign to them. A capacity provider must be associated with the cluster to be
	// used in a capacity provider strategy. The PutClusterCapacityProviders () API is
	// used to associate a capacity provider with a cluster. Only capacity providers
	// with an ACTIVE or UPDATING status can be used. If a capacityProviderStrategy is
	// specified, the launchType parameter must be omitted. If no
	// capacityProviderStrategy or launchType is specified, the
	// defaultCapacityProviderStrategy for the cluster is used. If specifying a
	// capacity provider that uses an Auto Scaling group, the capacity provider must
	// already be created. New capacity providers can be created with the
	// CreateCapacityProvider () API operation. To use a AWS Fargate capacity provider,
	// specify either the FARGATE or FARGATE_SPOT capacity providers. The AWS Fargate
	// capacity providers are available to all accounts and only need to be associated
	// with a cluster to be used. The PutClusterCapacityProviders () API operation is
	// used to update the list of available capacity providers for a cluster after the
	// cluster is created.
	CapacityProviderStrategy []*types.CapacityProviderStrategyItem
	// The launch type on which to run your task. 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. If a launchType is
	// specified, the capacityProviderStrategy parameter must be omitted.
	LaunchType types.LaunchType
	// Specifies whether to propagate the tags from the task definition to the task. If
	// no value is specified, the tags are not propagated. Tags can only be propagated
	// to the task during task creation. To add tags to a task after task creation, use
	// the TagResource () API action. An error will be received if you specify the
	// SERVICE option when running a task.
	PropagateTags types.PropagateTags
	// A list of container overrides in JSON format that specify the name of a
	// container in the specified task definition and the overrides it should receive.
	// You can override the default command for a container (that is specified in the
	// task definition or Docker image) with a command override. You can also override
	// existing environment variables (that are specified in the task definition or
	// Docker image) on a container or add new environment variables to it with an
	// environment override. A total of 8192 characters are allowed for overrides. This
	// limit includes the JSON formatting characters of the override structure.
	Overrides *types.TaskOverride
	// The reference ID to use for the task.
	ReferenceId *string
	// An optional tag specified when a task is started. For example, if you
	// automatically trigger a task to run a batch process job, you could apply a
	// unique identifier for that job to your task with the startedBy parameter. You
	// can then identify which tasks belong to that job by filtering the results of a
	// ListTasks () call with the startedBy value. Up to 36 letters (uppercase and
	// lowercase), numbers, hyphens, and underscores are allowed. If a task is started
	// by an Amazon ECS service, then the startedBy parameter contains the deployment
	// ID of the service that starts it.
	StartedBy *string
	// The network configuration for the task. This parameter is required for task
	// definitions that use the awsvpc network mode to receive their own elastic
	// network interface, and it is not supported for other network modes. For more
	// information, see Task Networking
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html)
	// in the Amazon Elastic Container Service Developer Guide.
	NetworkConfiguration *types.NetworkConfiguration
	// The short name or full Amazon Resource Name (ARN) of the cluster on which to run
	// your task. If you do not specify a cluster, the default cluster is assumed.
	Cluster *string
	// The name of the task group to associate with the task. The default value is the
	// family name of the task definition (for example, family:my-family-name).
	Group *string
	// An array of placement constraint objects to use for the task. You can specify up
	// to 10 constraints per task (including constraints in the task definition and
	// those specified at runtime).
	PlacementConstraints []*types.PlacementConstraint
	// The family and revision (family:revision) or full ARN of the task definition to
	// run. If a revision is not specified, the latest ACTIVE revision is used.
	TaskDefinition *string
	// The platform version the task should run. A platform version is only specified
	// for tasks using the Fargate launch type. If one is not specified, the LATEST
	// platform version is used by default. For more information, see AWS 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 number of instantiations of the specified task to place on your cluster. You
	// can specify up to 10 tasks per call.
	Count *int32
}

type RunTaskOutput struct {
	// A full description of the tasks that were run. The tasks that were successfully
	// placed on your cluster are described here.
	Tasks []*types.Task
	// Any failures associated with the call.
	Failures []*types.Failure

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StartTaskInput struct {
	// The family and revision (family:revision) or full ARN of the task definition to
	// start. If a revision is not specified, the latest ACTIVE revision is used.
	TaskDefinition *string
	// Specifies whether to enable Amazon ECS managed tags for the task. 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
	// The short name or full Amazon Resource Name (ARN) of the cluster on which to
	// start your task. If you do not specify a cluster, the default cluster is
	// assumed.
	Cluster *string
	// The VPC subnet and security group configuration for tasks that receive their own
	// elastic network interface by using the awsvpc networking mode.
	NetworkConfiguration *types.NetworkConfiguration
	// Specifies whether to propagate the tags from the task definition or the service
	// to the task. If no value is specified, the tags are not propagated.
	PropagateTags types.PropagateTags
	// An optional tag specified when a task is started. For example, if you
	// automatically trigger a task to run a batch process job, you could apply a
	// unique identifier for that job to your task with the startedBy parameter. You
	// can then identify which tasks belong to that job by filtering the results of a
	// ListTasks () call with the startedBy value. Up to 36 letters (uppercase and
	// lowercase), numbers, hyphens, and underscores are allowed. If a task is started
	// by an Amazon ECS service, then the startedBy parameter contains the deployment
	// ID of the service that starts it.
	StartedBy *string
	// A list of container overrides in JSON format that specify the name of a
	// container in the specified task definition and the overrides it should receive.
	// You can override the default command for a container (that is specified in the
	// task definition or Docker image) with a command override. You can also override
	// existing environment variables (that are specified in the task definition or
	// Docker image) on a container or add new environment variables to it with an
	// environment override. A total of 8192 characters are allowed for overrides. This
	// limit includes the JSON formatting characters of the override structure.
	Overrides *types.TaskOverride
	// The container instance IDs or full ARN entries for the container instances on
	// which you would like to place your task. You can specify up to 10 container
	// instances.
	ContainerInstances []*string
	// The name of the task group to associate with the task. The default value is the
	// family name of the task definition (for example, family:my-family-name).
	Group *string
	// The reference ID to use for the task.
	ReferenceId *string
	// The metadata that you apply to the task to help you categorize and organize
	// them. Each tag consists of a key and an optional value, both of which you
	// define. 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 AWS 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 []*types.Tag
}

type StartTaskOutput struct {
	// Any failures associated with the call.
	Failures []*types.Failure
	// A full description of the tasks that were started. Each task that was
	// successfully placed on your container instances is described.
	Tasks []*types.Task

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StopTaskInput struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// task to stop. If you do not specify a cluster, the default cluster is assumed.
	Cluster *string
	// The task ID or full Amazon Resource Name (ARN) of the task to stop.
	Task *string
	// An optional message specified when a task is stopped. For example, if you are
	// using a custom scheduler, you can use this parameter to specify the reason for
	// stopping the task here, and the message appears in subsequent DescribeTasks ()
	// API operations on this task. Up to 255 characters are allowed in this message.
	Reason *string
}

type StopTaskOutput struct {
	// The task that was stopped.
	Task *types.Task

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SubmitAttachmentStateChangesInput struct {
	// Any attachments associated with the state change request.
	Attachments []*types.AttachmentStateChange
	// The short name or full ARN of the cluster that hosts the container instance the
	// attachment belongs to.
	Cluster *string
}

type SubmitAttachmentStateChangesOutput struct {
	// Acknowledgement of the state change.
	Acknowledgment *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SubmitContainerStateChangeInput struct {
	// The network bindings of the container.
	NetworkBindings []*types.NetworkBinding
	// The name of the container.
	ContainerName *string
	// The reason for the state change request.
	Reason *string
	// The task ID or full Amazon Resource Name (ARN) of the task that hosts the
	// container.
	Task *string
	// The short name or full ARN of the cluster that hosts the container.
	Cluster *string
	// The exit code returned for the state change request.
	ExitCode *int32
	// The status of the state change request.
	Status *string
	// The ID of the Docker container.
	RuntimeId *string
}

type SubmitContainerStateChangeOutput struct {
	// Acknowledgement of the state change.
	Acknowledgment *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SubmitTaskStateChangeInput struct {
	// The status of the state change request.
	Status *string
	// The Unix timestamp for when the task execution stopped.
	ExecutionStoppedAt *time.Time
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// task.
	Cluster *string
	// Any attachments associated with the state change request.
	Attachments []*types.AttachmentStateChange
	// Any containers associated with the state change request.
	Containers []*types.ContainerStateChange
	// The reason for the state change request.
	Reason *string
	// The Unix timestamp for when the container image pull began.
	PullStartedAt *time.Time
	// The Unix timestamp for when the container image pull completed.
	PullStoppedAt *time.Time
	// The task ID or full ARN of the task in the state change request.
	Task *string
}

type SubmitTaskStateChangeOutput struct {
	// Acknowledgement of the state change.
	Acknowledgment *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TagResourceInput struct {
	// The tags to add to the resource. A tag is an array of key-value pairs. 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 AWS 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 []*types.Tag
	// The Amazon Resource Name (ARN) of the resource to which to add tags. Currently,
	// the supported resources are Amazon ECS capacity providers, tasks, services, task
	// definitions, clusters, and container instances.
	ResourceArn *string
}

type TagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UntagResourceInput struct {
	// The keys of the tags to be removed.
	TagKeys []*string
	// The Amazon Resource Name (ARN) of the resource from which to delete tags.
	// Currently, the supported resources are Amazon ECS capacity providers, tasks,
	// services, task definitions, clusters, and container instances.
	ResourceArn *string
}

type UntagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateClusterSettingsInput struct {
	// The name of the cluster to modify the settings for.
	Cluster *string
	// The setting to use by default for a cluster. This parameter is used to enable
	// CloudWatch Container Insights for a cluster. If this value is specified, it will
	// override the containerInsights value set with PutAccountSetting () or
	// PutAccountSettingDefault ().
	Settings []*types.ClusterSetting
}

type UpdateClusterSettingsOutput struct {
	// A regional grouping of one or more container instances on which you can run task
	// requests. Each account receives a default cluster the first time you use the
	// Amazon ECS service, but you may also create other clusters. Clusters may contain
	// more than one instance type simultaneously.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateContainerAgentInput struct {
	// The container instance ID or full ARN entries for the container instance on
	// which you would like to update the Amazon ECS container agent.
	ContainerInstance *string
	// The short name or full Amazon Resource Name (ARN) of the cluster that your
	// container instance is running on. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string
}

type UpdateContainerAgentOutput struct {
	// The container instance for which the container agent was updated.
	ContainerInstance *types.ContainerInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateContainerInstancesStateInput struct {
	// The container instance state with which to update the container instance. The
	// only valid values for this action are ACTIVE and DRAINING. A container instance
	// can only be updated to DRAINING status once it has reached an ACTIVE state. If a
	// container instance is in REGISTERING, DEREGISTERING, or REGISTRATION_FAILED
	// state you can describe the container instance but will be unable to update the
	// container instance state.
	Status types.ContainerInstanceStatus
	// A list of container instance IDs or full ARN entries.
	ContainerInstances []*string
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// container instance to update. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string
}

type UpdateContainerInstancesStateOutput struct {
	// The list of container instances.
	ContainerInstances []*types.ContainerInstance
	// Any failures associated with the call.
	Failures []*types.Failure

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateServiceInput struct {
	// The family and revision (family:revision) or full ARN of the task definition to
	// run in your service. If a revision is not specified, the latest ACTIVE revision
	// is used. If you modify the task definition with UpdateService, Amazon ECS spawns
	// a task with the new version of the task definition and then stops an old task
	// after the new version is running.
	TaskDefinition *string
	// The period of time, in seconds, that the Amazon ECS service scheduler should
	// ignore unhealthy Elastic Load Balancing target health checks after a task has
	// first started. This is only valid if your service is configured to use a load
	// balancer. If your service's tasks take a while to start and respond to Elastic
	// Load Balancing health checks, you can specify a health check grace period of up
	// to 2,147,483,647 seconds. During that time, the Amazon ECS service scheduler
	// ignores the Elastic Load Balancing health check status. This grace period can
	// prevent the ECS service scheduler from marking tasks as unhealthy and stopping
	// them before they have time to come up.
	HealthCheckGracePeriodSeconds *int32
	// The platform version on which your tasks in the service are running. A platform
	// version is only specified for tasks using the Fargate launch type. If a platform
	// version is not specified, the LATEST platform version is used by default. For
	// more information, see AWS Fargate Platform Versions
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
	// in the Amazon Elastic Container Service Developer Guide.
	PlatformVersion *string
	// Whether to force a new deployment of the service. Deployments are not forced by
	// default. You can use this option to trigger a new deployment with no service
	// definition changes. For example, you can update a service's tasks to use a newer
	// Docker image with the same image/tag combination (my_image:latest) or to roll
	// Fargate tasks onto a newer platform version.
	ForceNewDeployment *bool
	// An array of task placement constraint objects to update the service to use. If
	// no value is specified, the existing placement constraints for the service will
	// remain unchanged. If this value is specified, it will override any existing
	// placement constraints defined for the service. To remove all existing placement
	// constraints, specify an empty array. You can specify a maximum of 10 constraints
	// per task (this limit includes constraints in the task definition and those
	// specified at runtime).
	PlacementConstraints []*types.PlacementConstraint
	// Optional deployment parameters that control how many tasks run during the
	// deployment and the ordering of stopping and starting tasks.
	DeploymentConfiguration *types.DeploymentConfiguration
	// The capacity provider strategy to update the service to use. If the service is
	// using the default capacity provider strategy for the cluster, the service can be
	// updated to use one or more capacity providers as opposed to the default capacity
	// provider strategy. However, when a service is using a capacity provider strategy
	// that is not the default capacity provider strategy, the service cannot be
	// updated to use the cluster's default capacity provider strategy. A capacity
	// provider strategy consists of one or more capacity providers along with the base
	// and weight to assign to them. A capacity provider must be associated with the
	// cluster to be used in a capacity provider strategy. The
	// PutClusterCapacityProviders () API is used to associate a capacity provider with
	// a cluster. Only capacity providers with an ACTIVE or UPDATING status can be
	// used. If specifying a capacity provider that uses an Auto Scaling group, the
	// capacity provider must already be created. New capacity providers can be created
	// with the CreateCapacityProvider () API operation. To use a AWS Fargate capacity
	// provider, specify either the FARGATE or FARGATE_SPOT capacity providers. The AWS
	// Fargate capacity providers are available to all accounts and only need to be
	// associated with a cluster to be used. The PutClusterCapacityProviders () API
	// operation is used to update the list of available capacity providers for a
	// cluster after the cluster is created.
	CapacityProviderStrategy []*types.CapacityProviderStrategyItem
	// An object representing the network configuration for a task or service.
	NetworkConfiguration *types.NetworkConfiguration
	// The task placement strategy objects to update the service to use. If no value is
	// specified, the existing placement strategy for the service will remain
	// unchanged. If this value is specified, it will override the existing placement
	// strategy defined for the service. To remove an existing placement strategy,
	// specify an empty object. You can specify a maximum of five strategy rules per
	// service.
	PlacementStrategy []*types.PlacementStrategy
	// The short name or full Amazon Resource Name (ARN) of the cluster that your
	// service is running on. If you do not specify a cluster, the default cluster is
	// assumed.
	Cluster *string
	// The number of instantiations of the task to place and keep running in your
	// service.
	DesiredCount *int32
	// The name of the service to update.
	Service *string
}

type UpdateServiceOutput struct {
	// The full description of your service following the update call.
	Service *types.Service

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateServicePrimaryTaskSetInput struct {
	// The short name or full Amazon Resource Name (ARN) of the task set to set as the
	// primary task set in the deployment.
	PrimaryTaskSet *string
	// The short name or full Amazon Resource Name (ARN) of the service that the task
	// set exists in.
	Service *string
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task set exists in.
	Cluster *string
}

type UpdateServicePrimaryTaskSetOutput struct {
	// Information about a set of Amazon ECS tasks in either an AWS 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.
	TaskSet *types.TaskSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateTaskSetInput struct {
	// The short name or full Amazon Resource Name (ARN) of the task set to update.
	TaskSet *string
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task set exists in.
	Cluster *string
	// The short name or full Amazon Resource Name (ARN) of the service that the task
	// set exists in.
	Service *string
	// A floating-point percentage of the desired number of tasks to place and keep
	// running in the task set.
	Scale *types.Scale
}

type UpdateTaskSetOutput struct {
	// Information about a set of Amazon ECS tasks in either an AWS 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.
	TaskSet *types.TaskSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}