ecs

type AuthResolverParameters struct {
	// The name of the operation being invoked.
	Operation string

	// The region in which the operation is being invoked.
	Region string
}

type AuthSchemeResolver interface {
	ResolveAuthSchemes(context.Context, *AuthResolverParameters) ([]*smithyauth.Option, error)
}

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

type CreateCapacityProviderInput struct {

	// The details of the Auto Scaling group for the capacity provider.
	//
	// This member is required.
	AutoScalingGroupProvider *types.AutoScalingGroupProvider

	// The name of the capacity provider. Up to 255 characters are allowed. They
	// include letters (both upper and lowercase letters), numbers, underscores (_),
	// and hyphens (-). The name can't be prefixed with " aws ", " ecs ", or " fargate
	// ".
	//
	// This member is required.
	Name *string

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

type CreateCapacityProviderOutput struct {

	// The full description of the new capacity provider.
	CapacityProvider *types.CapacityProvider

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateClusterInput struct {

	// The short name of one or more capacity providers to associate with the cluster.
	// A capacity provider must be associated with a cluster before it can be included
	// as part of the default capacity provider strategy of the cluster or used in a
	// capacity provider strategy when calling the CreateService (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html)
	// or RunTask (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html)
	// actions. If specifying a capacity provider that uses an Auto Scaling group, the
	// capacity provider must be created but not associated with another cluster. New
	// Auto Scaling group capacity providers can be created with the
	// CreateCapacityProvider (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCapacityProvider.html)
	// API operation. To use a Fargate capacity provider, specify either the FARGATE
	// or FARGATE_SPOT capacity providers. The Fargate capacity providers are
	// available to all accounts and only need to be associated with a cluster to be
	// used. The PutCapacityProvider (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutCapacityProvider.html)
	// 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 don't specify a name for your cluster, you
	// create a cluster that's named default . Up to 255 letters (uppercase and
	// lowercase), numbers, underscores, and hyphens are allowed.
	ClusterName *string

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

	// The capacity provider strategy to set as the default for the cluster. After a
	// default capacity provider strategy is set for a cluster, when you call the
	// CreateService (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html)
	// or RunTask (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html)
	// APIs with no capacity provider strategy or launch type specified, the default
	// capacity provider strategy for the cluster is used. If a default capacity
	// provider strategy isn't defined for a cluster when it was created, it can be
	// defined later with the PutClusterCapacityProviders API operation.
	DefaultCapacityProviderStrategy []types.CapacityProviderStrategyItem

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

	// The setting to use when creating a cluster. This parameter is used to turn on
	// CloudWatch Container Insights for a cluster. If this value is specified, it
	// overrides the containerInsights value set with PutAccountSetting or
	// PutAccountSettingDefault .
	Settings []types.ClusterSetting

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

type CreateClusterOutput struct {

	// The full description of your new cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateServiceInput struct {

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

	// The capacity provider strategy to use for the service. 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. A capacity provider
	// strategy may contain a maximum of 6 capacity providers.
	CapacityProviderStrategy []types.CapacityProviderStrategyItem

	// An identifier that you provide to ensure the idempotency of the request. It
	// must be unique and is case sensitive. Up to 36 ASCII characters in the range of
	// 33-126 (inclusive) are allowed.
	ClientToken *string

	// The short name or full Amazon Resource Name (ARN) of the cluster that you run
	// your service on. If you do not specify a cluster, the default cluster is
	// assumed.
	Cluster *string

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

	// The deployment controller to use for the service. If no deployment controller
	// is specified, the default value of ECS is used.
	DeploymentController *types.DeploymentController

	// The number of instantiations of the specified task definition to place and keep
	// running in your service. This is required if schedulingStrategy is REPLICA or
	// isn't specified. If schedulingStrategy is DAEMON then this isn't required.
	DesiredCount *int32

	// Specifies whether to turn on 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. When you use Amazon ECS
	// managed tags, you need to set the propagateTags request parameter.
	EnableECSManagedTags bool

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

	// The period of time, in seconds, that the Amazon ECS service scheduler ignores
	// unhealthy Elastic Load Balancing target health checks after a task has first
	// started. 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 you do not
	// use an Elastic Load Balancing, we recommend that you use the startPeriod in the
	// task definition health check parameters. For more information, see Health check (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html)
	// . 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 (about 69 years). 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 infrastructure that you run your service on. For more information, see
	// Amazon ECS launch types (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
	// in the Amazon Elastic Container Service Developer Guide. The FARGATE launch
	// type runs your tasks on Fargate On-Demand infrastructure. Fargate Spot
	// infrastructure is available for use but a capacity provider strategy must be
	// used. For more information, see Fargate capacity providers (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-capacity-providers.html)
	// in the Amazon ECS Developer Guide. The EC2 launch type runs your tasks on
	// Amazon EC2 instances registered to your cluster. The EXTERNAL launch type runs
	// your tasks on your on-premises server or virtual machine (VM) capacity
	// registered to your cluster. A service can use either a launch type or a capacity
	// provider strategy. If a launchType is specified, the capacityProviderStrategy
	// parameter must be omitted.
	LaunchType types.LaunchType

	// 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 uses the
	// rolling update ( ECS ) deployment controller and using either an Application
	// Load Balancer or Network Load Balancer, you must specify one or more target
	// group ARNs to attach to the service. The service-linked role is required for
	// services that use 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 uses the
	// CODE_DEPLOY deployment controller, the service is required to use either an
	// Application Load Balancer or Network Load Balancer. When creating an CodeDeploy
	// deployment group, you specify two target groups (referred to as a
	// targetGroupPair ). During a deployment, CodeDeploy determines which task set in
	// your service has the status PRIMARY , and it associates one target group with
	// it. Then, it also 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 you can use to perform
	// validation tests with Lambda functions before routing production traffic to it.
	// If you use 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, and the container port to access from the load balancer. The
	// container name must be as it appears in a container definition. The load
	// balancer name parameter must be omitted. 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 that's specified here. For Classic
	// Load Balancers, this object must contain the load balancer name, the container
	// name , and the container port to access from the load balancer. The container
	// name must be as it appears in a container definition. The target group ARN
	// parameter must be omitted. When a task from this service is placed on a
	// container instance, the container instance is registered with the load balancer
	// that's 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 aren't supported.
	// Also, when you create any target groups for these services, you must choose ip
	// as the target type, not instance . This is 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 isn't 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

	// An array of placement constraint objects to use for tasks in your service. You
	// can specify a maximum of 10 constraints for each task. This limit includes
	// constraints in the task definition and those specified at runtime.
	PlacementConstraints []types.PlacementConstraint

	// The placement strategy objects to use for tasks in your service. You can
	// specify a maximum of 5 strategy rules for each service.
	PlacementStrategy []types.PlacementStrategy

	// 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. For more information, see
	// Fargate platform versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
	// in the Amazon Elastic Container Service Developer Guide.
	PlatformVersion *string

	// Specifies whether to propagate the tags from the task definition to the task.
	// If no value is specified, the tags aren't propagated. Tags can only be
	// propagated to the task during task creation. To add tags to a task after task
	// creation, use the TagResource (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html)
	// API action. You must set this to a value other than NONE when you use Cost
	// Explorer. For more information, see Amazon ECS usage reports (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/usage-reports.html)
	// in the Amazon Elastic Container Service Developer Guide. The default is NONE .
	PropagateTags types.PropagateTags

	// 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 doesn't 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 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 don't 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 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 uses 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 don't 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 configuration for this service to discover and connect to services, and be
	// discovered by, and connected from, other services within a namespace. Tasks that
	// run in a namespace can use short names to connect to services in the namespace.
	// Tasks can connect to services across all of the clusters in the namespace. Tasks
	// connect through a managed proxy container that collects logs and metrics for
	// increased visibility. Only the tasks that Amazon ECS services create are
	// supported with Service Connect. For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectConfiguration *types.ServiceConnectConfiguration

	// The details of the service discovery registry to associate with this service.
	// For more information, see Service discovery (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html)
	// . Each service may be associated with one service registry. Multiple service
	// registries for each service isn't supported.
	ServiceRegistries []types.ServiceRegistry

	// 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 Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	Tags []types.Tag

	// The family and revision ( family:revision ) or full ARN of the task definition
	// to run in your service. If a revision isn't specified, the latest ACTIVE
	// revision is used. A task definition must be specified if the service uses either
	// the ECS or CODE_DEPLOY deployment controllers. For more information about
	// deployment types, see Amazon ECS deployment types (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)
	// .
	TaskDefinition *string

	// The configuration for a volume specified in the task definition as a volume
	// that is configured at launch time. Currently, the only supported volume type is
	// an Amazon EBS volume.
	VolumeConfigurations []types.ServiceVolumeConfiguration
	// contains filtered or unexported fields
}

type CreateServiceOutput struct {

	// The full description of your service following the create call. A service will
	// return either a capacityProviderStrategy or launchType parameter, but not both,
	// depending where one was specified when it was created. If a service is using the
	// ECS deployment controller, the deploymentController and taskSets parameters
	// will not be returned. if the service uses 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
	// contains filtered or unexported fields
}

type CreateTaskSetInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service to create the task set in.
	//
	// This member is required.
	Cluster *string

	// The short name or full Amazon Resource Name (ARN) of the service to create the
	// task set in.
	//
	// This member is required.
	Service *string

	// The task definition for the tasks in the task set to use. If a revision isn't
	// specified, the latest ACTIVE revision is used.
	//
	// This member is required.
	TaskDefinition *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 Fargate capacity provider,
	// specify either the FARGATE or FARGATE_SPOT capacity providers. The 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 identifier that you provide to ensure the idempotency of the request. It
	// must be unique and is case sensitive. Up to 36 ASCII characters in the range of
	// 33-126 (inclusive) are allowed.
	ClientToken *string

	// 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 Cloud Map attribute set to
	// the provided value.
	ExternalId *string

	// The launch type that new tasks in the task set uses. 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

	// 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 object representing the network configuration for a task set.
	NetworkConfiguration *types.NetworkConfiguration

	// The platform version that the tasks in the task set uses. A platform version is
	// specified only for tasks using the Fargate launch type. If one isn't specified,
	// the LATEST platform version is used.
	PlatformVersion *string

	// A floating-point percentage of the desired number of tasks to place and keep
	// running in the task set.
	Scale *types.Scale

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

type CreateTaskSetOutput struct {

	// Information about a set of Amazon ECS tasks in either an CodeDeploy or an
	// EXTERNAL deployment. A 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
	// contains filtered or unexported fields
}

type DeleteAccountSettingInput struct {

	// The resource name to disable the account setting for. 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.
	//
	// This member is required.
	Name types.SettingName

	// The Amazon Resource Name (ARN) of the principal. It can be an user, role, or
	// the root user. If you specify the root user, it disables the account setting for
	// all users, roles, and the root user of the account unless a user or role
	// explicitly overrides these settings. If this field is omitted, the setting is
	// changed only for the authenticated user.
	PrincipalArn *string
	// contains filtered or unexported fields
}

type DeleteAccountSettingOutput struct {

	// The account setting for the specified principal ARN.
	Setting *types.Setting

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteAttributesInput struct {

	// The attributes to delete from your resource. You can specify up to 10
	// attributes for each request. For custom attributes, specify the attribute name
	// and target ID, but don't specify the value. If you specify the target ID using
	// the short form, you must also specify the target type.
	//
	// This member is required.
	Attributes []types.Attribute

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

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

type DeleteCapacityProviderInput struct {

	// The short name or full Amazon Resource Name (ARN) of the capacity provider to
	// delete.
	//
	// This member is required.
	CapacityProvider *string
	// contains filtered or unexported fields
}

type DeleteCapacityProviderOutput struct {

	// The details of the capacity provider.
	CapacityProvider *types.CapacityProvider

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteClusterInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster to delete.
	//
	// This member is required.
	Cluster *string
	// contains filtered or unexported fields
}

type DeleteClusterOutput struct {

	// The full description of the deleted cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteServiceInput struct {

	// The name of the service to delete.
	//
	// This member is required.
	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

	// If true , allows you to delete a service even if it wasn't scaled down to zero
	// tasks. It's only necessary to use this if the service uses the REPLICA
	// scheduling strategy.
	Force *bool
	// contains filtered or unexported fields
}

type DeleteServiceOutput struct {

	// The full description of the deleted service.
	Service *types.Service

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteTaskDefinitionsInput struct {

	// The family and revision ( family:revision ) or full Amazon Resource Name (ARN)
	// of the task definition to delete. You must specify a revision . You can specify
	// up to 10 task definitions as a comma separated list.
	//
	// This member is required.
	TaskDefinitions []string
	// contains filtered or unexported fields
}

type DeleteTaskDefinitionsOutput struct {

	// Any failures associated with the call.
	Failures []types.Failure

	// The list of deleted task definitions.
	TaskDefinitions []types.TaskDefinition

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteTaskSetInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task set found in to delete.
	//
	// This member is required.
	Cluster *string

	// The short name or full Amazon Resource Name (ARN) of the service that hosts the
	// task set to delete.
	//
	// This member is required.
	Service *string

	// The task set ID or full Amazon Resource Name (ARN) of the task set to delete.
	//
	// This member is required.
	TaskSet *string

	// If true , you can delete a task set even if it hasn't been scaled down to zero.
	Force *bool
	// contains filtered or unexported fields
}

type DeleteTaskSetOutput struct {

	// Details about the task set.
	TaskSet *types.TaskSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeregisterContainerInstanceInput struct {

	// The container instance ID or full ARN of the container instance to deregister.
	// For more information about the ARN format, see Amazon Resource Name (ARN) (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#ecs-resource-ids)
	// in the Amazon ECS Developer Guide.
	//
	// This member is required.
	ContainerInstance *string

	// 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

	// Forces the container instance to be deregistered. 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're 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
	// contains filtered or unexported fields
}

type DeregisterContainerInstanceOutput struct {

	// The container instance that was deregistered.
	ContainerInstance *types.ContainerInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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 .
	//
	// This member is required.
	TaskDefinition *string
	// contains filtered or unexported fields
}

type DeregisterTaskDefinitionOutput struct {

	// The full description of the deregistered task.
	TaskDefinition *types.TaskDefinition

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeCapacityProvidersInput struct {

	// 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

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

type DescribeCapacityProvidersOutput struct {

	// The list of capacity providers.
	CapacityProviders []types.CapacityProvider

	// Any failures associated with the call.
	Failures []types.Failure

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

type DescribeClustersInput struct {

	// 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

	// Determines whether to include additional information about the clusters in the
	// response. If this field is omitted, this information isn't included. If
	// ATTACHMENTS is specified, the attachments for the container instances or tasks
	// within the cluster are included, for example the capacity providers. If SETTINGS
	// is specified, the settings for the cluster are included. If CONFIGURATIONS is
	// specified, the configuration for the cluster is included. If STATISTICS is
	// specified, the task and service count is included, separated by launch type. If
	// TAGS is specified, the metadata tags associated with the cluster are included.
	Include []types.ClusterField
	// contains filtered or unexported fields
}

type DescribeClustersOutput struct {

	// The list of clusters.
	Clusters []types.Cluster

	// Any failures associated with the call.
	Failures []types.Failure

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeContainerInstancesInput struct {

	// A list of up to 100 container instance IDs or full Amazon Resource Name (ARN)
	// entries.
	//
	// This member is required.
	ContainerInstances []string

	// 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

	// 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
	// CONTAINER_INSTANCE_HEALTH is specified, the container instance health is
	// included in the response. If this field is omitted, tags and container instance
	// health status aren't included in the response.
	Include []types.ContainerInstanceField
	// contains filtered or unexported fields
}

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

type DescribeServicesAPIClient interface {
	DescribeServices(context.Context, *DescribeServicesInput, ...func(*Options)) (*DescribeServicesOutput, error)
}

type DescribeServicesInput struct {

	// A list of services to describe. You may specify up to 10 services to describe
	// in a single operation.
	//
	// This member is required.
	Services []string

	// 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

	// Determines 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 aren't included in the response.
	Include []types.ServiceField
	// contains filtered or unexported fields
}

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

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.
	//
	// This member is required.
	TaskDefinition *string

	// Determines 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
	// aren't included in the response.
	Include []types.TaskDefinitionField
	// contains filtered or unexported fields
}

type DescribeTaskDefinitionOutput struct {

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

	// The full task definition description.
	TaskDefinition *types.TaskDefinition

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeTaskSetsInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task sets exist in.
	//
	// This member is required.
	Cluster *string

	// The short name or full Amazon Resource Name (ARN) of the service that the task
	// sets exist in.
	//
	// This member is required.
	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
	// aren't included in the response.
	Include []types.TaskSetField

	// The ID or full Amazon Resource Name (ARN) of task sets to describe.
	TaskSets []string
	// contains filtered or unexported fields
}

type DescribeTaskSetsOutput struct {

	// Any failures associated with the call.
	Failures []types.Failure

	// The list of task sets described.
	TaskSets []types.TaskSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeTasksAPIClient interface {
	DescribeTasks(context.Context, *DescribeTasksInput, ...func(*Options)) (*DescribeTasksOutput, error)
}

type DescribeTasksInput struct {

	// A list of up to 100 task IDs or full ARN entries.
	//
	// This member is required.
	Tasks []string

	// 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

	// 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
	// aren't included in the response.
	Include []types.TaskField
	// contains filtered or unexported fields
}

type DescribeTasksOutput struct {

	// Any failures associated with the call.
	Failures []types.Failure

	// The list of tasks.
	Tasks []types.Task

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DiscoverPollEndpointInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster that the
	// container instance belongs to.
	Cluster *string

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

type DiscoverPollEndpointOutput struct {

	// The endpoint for the Amazon ECS agent to poll.
	Endpoint *string

	// The endpoint for the Amazon ECS agent to poll for Service Connect
	// configuration. For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectEndpoint *string

	// The telemetry endpoint for the Amazon ECS agent.
	TelemetryEndpoint *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type EndpointParameters struct {
	// The AWS region used to dispatch the request.
	//
	// Parameter is
	// required.
	//
	// AWS::Region
	Region *string

	// When true, use the dual-stack endpoint. If the configured endpoint does not
	// support dual-stack, dispatching the request MAY return an error.
	//
	// Defaults to
	// false if no value is provided.
	//
	// AWS::UseDualStack
	UseDualStack *bool

	// When true, send this request to the FIPS-compliant regional endpoint. If the
	// configured endpoint does not have a FIPS compliant endpoint, dispatching the
	// request will return an error.
	//
	// Defaults to false if no value is
	// provided.
	//
	// AWS::UseFIPS
	UseFIPS *bool

	// Override the endpoint used to send this request
	//
	// Parameter is
	// required.
	//
	// SDK::Endpoint
	Endpoint *string
}

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

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

type EndpointResolverOptions = internalendpoints.Options

type EndpointResolverV2 interface {
	// ResolveEndpoint attempts to resolve the endpoint with the provided options,
	// returning the endpoint if found. Otherwise an error is returned.
	ResolveEndpoint(ctx context.Context, params EndpointParameters) (
		smithyendpoints.Endpoint, error,
	)
}

type ExecuteCommandInput struct {

	// The command to run on the container.
	//
	// This member is required.
	Command *string

	// Use this flag to run your command in interactive mode.
	//
	// This member is required.
	Interactive bool

	// The Amazon Resource Name (ARN) or ID of the task the container is part of.
	//
	// This member is required.
	Task *string

	// The Amazon Resource Name (ARN) or short name of the cluster the task is running
	// in. If you do not specify a cluster, the default cluster is assumed.
	Cluster *string

	// The name of the container to execute the command on. A container name only
	// needs to be specified for tasks containing multiple containers.
	Container *string
	// contains filtered or unexported fields
}

type ExecuteCommandOutput struct {

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

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

	// The name of the container.
	ContainerName *string

	// Determines whether the execute command session is running in interactive mode.
	// Amazon ECS only supports initiating interactive sessions, so you must specify
	// true for this value.
	Interactive bool

	// The details of the SSM session that was created for this instance of
	// execute-command.
	Session *types.Session

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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetTaskProtectionInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task sets exist in.
	//
	// This member is required.
	Cluster *string

	// A list of up to 100 task IDs or full ARN entries.
	Tasks []string
	// contains filtered or unexported fields
}

type GetTaskProtectionOutput struct {

	// Any failures associated with the call.
	Failures []types.Failure

	// A list of tasks with the following information.
	//   - taskArn : The task ARN.
	//   - protectionEnabled : The protection status of the task. If scale-in
	//   protection is turned on for a task, the value is true . Otherwise, it is false
	//   .
	//   - expirationDate : The epoch time when protection for the task will expire.
	ProtectedTasks []types.ProtectedTask

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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, optFns ...func(*v4.SignerOptions)) error
}

type IdempotencyTokenProvider interface {
	GetIdempotencyToken() (string, error)
}

type ListAccountSettingsAPIClient interface {
	ListAccountSettings(context.Context, *ListAccountSettingsInput, ...func(*Options)) (*ListAccountSettingsOutput, error)
}

type ListAccountSettingsInput struct {

	// Determines 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're set. Otherwise, no account settings are returned.
	EffectiveSettings bool

	// 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 isn't used, then
	// ListAccountSettings returns up to 10 results and a nextToken value if
	// applicable.
	MaxResults int32

	// The name of the account setting you want to list the settings for.
	Name types.SettingName

	// 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's 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 ARN of the principal, which can be a user, role, or the root user. If this
	// field is omitted, the account settings are listed only for the authenticated
	// user. Federated users assume the account setting of the root user and can't have
	// explicit account settings set for them.
	PrincipalArn *string

	// The value of the account settings to filter results with. You must also specify
	// an account setting name to use this parameter.
	Value *string
	// contains filtered or unexported fields
}

type ListAccountSettingsOutput struct {

	// 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

	// The account settings for the resource.
	Settings []types.Setting

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListAccountSettingsPaginatorOptions 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 isn't used, then
	// ListAccountSettings returns up to 10 results and a nextToken value if
	// applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListAttributesAPIClient interface {
	ListAttributes(context.Context, *ListAttributesInput, ...func(*Options)) (*ListAttributesOutput, error)
}

type ListAttributesInput struct {

	// The type of the target to list attributes with.
	//
	// This member is required.
	TargetType types.TargetType

	// The name of the attribute to filter the results with.
	AttributeName *string

	// The value of the attribute to filter results with. You must also specify an
	// attribute name to use this parameter.
	AttributeValue *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 maximum number of cluster results that ListAttributes returned 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 isn't 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 are needed. If
	// maxResults was provided, it's 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
	// contains filtered or unexported fields
}

type ListAttributesOutput struct {

	// A list of attribute objects that meet the criteria of the request.
	Attributes []types.Attribute

	// 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListAttributesPaginatorOptions struct {
	// The maximum number of cluster results that ListAttributes returned 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 isn't used, then ListAttributes returns up to 100 results and
	// a nextToken value if applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListClustersAPIClient interface {
	ListClusters(context.Context, *ListClustersInput, ...func(*Options)) (*ListClustersOutput, error)
}

type ListClustersInput struct {

	// The maximum number of cluster results that ListClusters returned 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 isn't 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 are needed. If
	// maxResults was provided, it's 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
	// contains filtered or unexported fields
}

type ListClustersOutput struct {

	// The list of full Amazon Resource Name (ARN) entries for each cluster that's
	// 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
	// contains filtered or unexported fields
}

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

type ListClustersPaginatorOptions struct {
	// The maximum number of cluster results that ListClusters returned 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 isn't used, then ListClusters returns up to 100 results and a
	// nextToken value if applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListContainerInstancesAPIClient interface {
	ListContainerInstances(context.Context, *ListContainerInstancesInput, ...func(*Options)) (*ListContainerInstancesOutput, error)
}

type ListContainerInstancesInput struct {

	// 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

	// 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 maximum number of container instance results that ListContainerInstances
	// returned 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 isn't
	// 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 are
	// needed. If maxResults was provided, it's 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

	// 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 don't specify this
	// parameter, the default is to include container instances set to all states other
	// than INACTIVE .
	Status types.ContainerInstanceStatus
	// contains filtered or unexported fields
}

type ListContainerInstancesOutput struct {

	// The list of container instances with full ARN entries for each container
	// instance associated with the specified cluster.
	ContainerInstanceArns []string

	// 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListContainerInstancesPaginatorOptions struct {
	// The maximum number of container instance results that ListContainerInstances
	// returned 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 isn't
	// used, then ListContainerInstances returns up to 100 results and a nextToken
	// value if applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListServicesAPIClient interface {
	ListServices(context.Context, *ListServicesInput, ...func(*Options)) (*ListServicesOutput, error)
}

type ListServicesByNamespaceAPIClient interface {
	ListServicesByNamespace(context.Context, *ListServicesByNamespaceInput, ...func(*Options)) (*ListServicesByNamespaceOutput, error)
}

type ListServicesByNamespaceInput struct {

	// The namespace name or full Amazon Resource Name (ARN) of the Cloud Map
	// namespace to list the services in. Tasks that run in a namespace can use short
	// names to connect to services in the namespace. Tasks can connect to services
	// across all of the clusters in the namespace. Tasks connect through a managed
	// proxy container that collects logs and metrics for increased visibility. Only
	// the tasks that Amazon ECS services create are supported with Service Connect.
	// For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	// This member is required.
	Namespace *string

	// The maximum number of service results that ListServicesByNamespace returns in
	// paginated output. When this parameter is used, ListServicesByNamespace 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 ListServicesByNamespace request with the returned nextToken value. This
	// value can be between 1 and 100. If this parameter isn't used, then
	// ListServicesByNamespace returns up to 10 results and a nextToken value if
	// applicable.
	MaxResults *int32

	// The nextToken value that's returned from a ListServicesByNamespace request. It
	// indicates that more results are available to fulfill the request and further
	// calls are needed. If maxResults is returned, it is possible the number of
	// results is less than maxResults .
	NextToken *string
	// contains filtered or unexported fields
}

type ListServicesByNamespaceOutput struct {

	// The nextToken value to include in a future ListServicesByNamespace request.
	// When the results of a ListServicesByNamespace request exceed maxResults , this
	// value can be used to retrieve the next page of results. When there are no more
	// results to return, this value is null .
	NextToken *string

	// The list of full ARN entries for each service that's associated with the
	// specified namespace.
	ServiceArns []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListServicesByNamespacePaginatorOptions struct {
	// The maximum number of service results that ListServicesByNamespace returns in
	// paginated output. When this parameter is used, ListServicesByNamespace 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 ListServicesByNamespace request with the returned nextToken value. This
	// value can be between 1 and 100. If this parameter isn't used, then
	// ListServicesByNamespace returns up to 10 results and a nextToken value if
	// applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListServicesInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster to use when
	// filtering the ListServices results. If you do not specify a cluster, the
	// default cluster is assumed.
	Cluster *string

	// The launch type to use when filtering the ListServices results.
	LaunchType types.LaunchType

	// The maximum number of service results that ListServices returned 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 isn't used, then ListServices returns up to 10 results and a
	// nextToken value if applicable.
	MaxResults *int32

	// 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 to use when filtering the ListServices results.
	SchedulingStrategy types.SchedulingStrategy
	// contains filtered or unexported fields
}

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 that's associated with the
	// specified cluster.
	ServiceArns []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListServicesPaginatorOptions struct {
	// The maximum number of service results that ListServices returned 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 isn't used, then ListServices returns up to 10 results and a
	// nextToken value if applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListTagsForResourceInput struct {

	// The Amazon Resource Name (ARN) that identifies the resource to list the tags
	// for. Currently, the supported resources are Amazon ECS tasks, services, task
	// definitions, clusters, and container instances.
	//
	// This member is required.
	ResourceArn *string
	// contains filtered or unexported fields
}

type ListTagsForResourceOutput struct {

	// The tags for the resource.
	Tags []types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListTaskDefinitionFamiliesAPIClient interface {
	ListTaskDefinitionFamilies(context.Context, *ListTaskDefinitionFamiliesInput, ...func(*Options)) (*ListTaskDefinitionFamiliesOutput, error)
}

type ListTaskDefinitionFamiliesInput struct {

	// The familyPrefix is a string that's 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 that
	// ListTaskDefinitionFamilies returned 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 isn't used, then ListTaskDefinitionFamilies returns up to 100 results
	// and a nextToken value if applicable.
	MaxResults *int32

	// 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 task definition family status to filter the ListTaskDefinitionFamilies
	// results with. 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
	// contains filtered or unexported fields
}

type ListTaskDefinitionFamiliesOutput struct {

	// The list of task definition family names that match the
	// ListTaskDefinitionFamilies request.
	Families []string

	// 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListTaskDefinitionFamiliesPaginatorOptions struct {
	// The maximum number of task definition family results that
	// ListTaskDefinitionFamilies returned 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 isn't used, then ListTaskDefinitionFamilies returns up to 100 results
	// and a nextToken value if applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListTaskDefinitionsAPIClient interface {
	ListTaskDefinitions(context.Context, *ListTaskDefinitionsInput, ...func(*Options)) (*ListTaskDefinitionsOutput, error)
}

type ListTaskDefinitionsInput struct {

	// The full family name to filter the ListTaskDefinitions results with. Specifying
	// a familyPrefix limits the listed task definitions to task definition revisions
	// that belong to that family.
	FamilyPrefix *string

	// The maximum number of task definition results that ListTaskDefinitions returned
	// 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 isn't used, then
	// ListTaskDefinitions returns up to 100 results and a nextToken value if
	// applicable.
	MaxResults *int32

	// 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 to sort the results in. 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. This is so that the newest task definitions in a
	// family are listed first.
	Sort types.SortOrder

	// The task definition status to filter the ListTaskDefinitions results with. 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
	// contains filtered or unexported fields
}

type ListTaskDefinitionsOutput struct {

	// 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

	// The list of task definition Amazon Resource Name (ARN) entries for the
	// ListTaskDefinitions request.
	TaskDefinitionArns []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListTaskDefinitionsPaginatorOptions struct {
	// The maximum number of task definition results that ListTaskDefinitions returned
	// 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 isn't used, then
	// ListTaskDefinitions returns up to 100 results and a nextToken value if
	// applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListTasksAPIClient interface {
	ListTasks(context.Context, *ListTasksInput, ...func(*Options)) (*ListTasksOutput, error)
}

type ListTasksInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster to use when
	// filtering the ListTasks results. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string

	// The container instance ID or full ARN of the container instance to use when
	// filtering the ListTasks results. Specifying a containerInstance limits the
	// results to tasks that belong to that container instance.
	ContainerInstance *string

	// The task desired status to use when filtering 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
	// aren't 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 doesn't 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

	// The name of the task definition family to use when filtering the ListTasks
	// results. Specifying a family limits the results to tasks that belong to that
	// family.
	Family *string

	// The launch type to use when filtering the ListTasks results.
	LaunchType types.LaunchType

	// The maximum number of task results that ListTasks returned 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 isn't 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's 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 name of the service to use when filtering the ListTasks results. Specifying
	// a serviceName limits the results to tasks that belong to that service.
	ServiceName *string

	// The startedBy value to filter the task results with. Specifying a startedBy
	// value limits the results to tasks that were started with that value. When you
	// specify startedBy as the filter, it must be the only filter that you use.
	StartedBy *string
	// contains filtered or unexported fields
}

type ListTasksOutput struct {

	// 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

	// The list of task ARN entries for the ListTasks request.
	TaskArns []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListTasksPaginatorOptions struct {
	// The maximum number of task results that ListTasks returned 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 isn't used, then ListTasks returns up to 100 results and a nextToken
	// value if applicable.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

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 optional application specific identifier appended to the User-Agent header.
	AppID string

	// This endpoint will be given as input to an EndpointResolverV2. It is used for
	// providing a custom base endpoint that is subject to modifications by the
	// processing EndpointResolverV2.
	BaseEndpoint *string

	// Configures the events that will be sent to the configured logger.
	ClientLogMode aws.ClientLogMode

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

	// The configuration DefaultsMode that the SDK should use when constructing the
	// clients initial default settings.
	DefaultsMode aws.DefaultsMode

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

	// The service endpoint resolver.
	//
	// Deprecated: Deprecated: EndpointResolver and WithEndpointResolver. Providing a
	// value for this field will likely prevent you from using any endpoint-related
	// service features released after the introduction of EndpointResolverV2 and
	// BaseEndpoint. To migrate an EndpointResolver implementation that uses a custom
	// endpoint, set the client option BaseEndpoint instead.
	EndpointResolver EndpointResolver

	// Resolves the endpoint used for a particular service operation. This should be
	// used over the deprecated EndpointResolver.
	EndpointResolverV2 EndpointResolverV2

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// Provides idempotency tokens values that will be automatically populated into
	// idempotent API operations.
	IdempotencyTokenProvider IdempotencyTokenProvider

	// The logger writer interface to write logging messages to.
	Logger logging.Logger

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

	// RetryMaxAttempts specifies the maximum number attempts an API client will call
	// an operation that fails with a retryable error. A value of 0 is ignored, and
	// will not be used to configure the API client created default retryer, or modify
	// per operation call's retry max attempts. If specified in an operation call's
	// functional options with a value that is different than the constructed client's
	// Options, the Client's Retryer will be wrapped to use the operation's specific
	// RetryMaxAttempts value.
	RetryMaxAttempts int

	// RetryMode specifies the retry mode the API client will be created with, if
	// Retryer option is not also specified. When creating a new API Clients this
	// member will only be used if the Retryer Options member is nil. This value will
	// be ignored if Retryer is not nil. Currently does not support per operation call
	// overrides, may in the future.
	RetryMode aws.RetryMode

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer. The kind of
	// default retry created by the API client can be changed with the RetryMode
	// option.
	Retryer aws.Retryer

	// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
	// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
	// should not populate this structure programmatically, or rely on the values here
	// within your applications.
	RuntimeEnvironment aws.RuntimeEnvironment

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

	// The auth scheme resolver which determines how to authenticate for each
	// operation.
	AuthSchemeResolver AuthSchemeResolver

	// The list of auth schemes supported by the client.
	AuthSchemes []smithyhttp.AuthScheme
	// contains filtered or unexported fields
}

type PutAccountSettingDefaultInput struct {

	// The resource name for which to modify the account setting. The following are
	// the valid values for the account setting name.
	//   - serviceLongArnFormat - When modified, the Amazon Resource Name (ARN) and
	//   resource ID format of the resource type for a specified user, role, or the root
	//   user for an account is affected. The opt-in and opt-out account setting must be
	//   set for each Amazon ECS resource separately. The ARN and resource ID format of a
	//   resource is defined by the opt-in status of the user or role that created the
	//   resource. You must turn on this setting to use Amazon ECS features such as
	//   resource tagging.
	//   - taskLongArnFormat - When modified, the Amazon Resource Name (ARN) and
	//   resource ID format of the resource type for a specified user, role, or the root
	//   user for an account is affected. The opt-in and opt-out account setting must be
	//   set for each Amazon ECS resource separately. The ARN and resource ID format of a
	//   resource is defined by the opt-in status of the user or role that created the
	//   resource. You must turn on this setting to use Amazon ECS features such as
	//   resource tagging.
	//   - containerInstanceLongArnFormat - When modified, the Amazon Resource Name
	//   (ARN) and resource ID format of the resource type for a specified user, role, or
	//   the root user for an account is affected. The opt-in and opt-out account setting
	//   must be set for each Amazon ECS resource separately. The ARN and resource ID
	//   format of a resource is defined by the opt-in status of the user or role that
	//   created the resource. You must turn on this setting to use Amazon ECS features
	//   such as resource tagging.
	//   - awsvpcTrunking - When modified, the elastic network interface (ENI) limit
	//   for any new container instances that support the feature is changed. If
	//   awsvpcTrunking is turned on, any new container instances that support the
	//   feature are launched have the increased ENI limits available to them. For more
	//   information, see Elastic Network Interface Trunking (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html)
	//   in the Amazon Elastic Container Service Developer Guide.
	//   - containerInsights - When modified, the default setting indicating whether
	//   Amazon Web Services CloudWatch Container Insights is turned on for your clusters
	//   is changed. If containerInsights is turned on, any new clusters that are
	//   created will have Container Insights turned on unless you disable it during
	//   cluster creation. For more information, see CloudWatch Container Insights (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-container-insights.html)
	//   in the Amazon Elastic Container Service Developer Guide.
	//   - dualStackIPv6 - When turned on, when using a VPC in dual stack mode, your
	//   tasks using the awsvpc network mode can have an IPv6 address assigned. For
	//   more information on using IPv6 with tasks launched on Amazon EC2 instances, see
	//   Using a VPC in dual-stack mode (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking-awsvpc.html#task-networking-vpc-dual-stack)
	//   . For more information on using IPv6 with tasks launched on Fargate, see
	//   Using a VPC in dual-stack mode (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-task-networking.html#fargate-task-networking-vpc-dual-stack)
	//   .
	//   - fargateFIPSMode - If you specify fargateFIPSMode , Fargate FIPS 140
	//   compliance is affected.
	//   - fargateTaskRetirementWaitPeriod - When Amazon Web Services determines that a
	//   security or infrastructure update is needed for an Amazon ECS task hosted on
	//   Fargate, the tasks need to be stopped and new tasks launched to replace them.
	//   Use fargateTaskRetirementWaitPeriod to configure the wait time to retire a
	//   Fargate task. For information about the Fargate tasks maintenance, see Amazon
	//   Web Services Fargate task maintenance (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-maintenance.html)
	//   in the Amazon ECS Developer Guide.
	//   - tagResourceAuthorization - Amazon ECS is introducing tagging authorization
	//   for resource creation. Users must have permissions for actions that create the
	//   resource, such as ecsCreateCluster . If tags are specified when you create a
	//   resource, Amazon Web Services performs additional authorization to verify if
	//   users or roles have permissions to create tags. Therefore, you must grant
	//   explicit permissions to use the ecs:TagResource action. For more information,
	//   see Grant permission to tag resources on creation (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/supported-iam-actions-tagging.html)
	//   in the Amazon ECS Developer Guide.
	//   - guardDutyActivate - The guardDutyActivate parameter is read-only in Amazon
	//   ECS and indicates whether Amazon ECS Runtime Monitoring is enabled or disabled
	//   by your security administrator in your Amazon ECS account. Amazon GuardDuty
	//   controls this account setting on your behalf. For more information, see
	//   Protecting Amazon ECS workloads with Amazon ECS Runtime Monitoring (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-guard-duty-integration.html)
	//   .
	//
	// This member is required.
	Name types.SettingName

	// The account setting value for the specified principal ARN. Accepted values are
	// enabled , disabled , on , and off . When you specify
	// fargateTaskRetirementWaitPeriod for the name , the following are the valid
	// values:
	//   - 0 - Amazon Web Services sends the notification, and immediately retires the
	//   affected tasks.
	//   - 7 - Amazon Web Services sends the notification, and waits 7 calendar days to
	//   retire the tasks.
	//   - 14 - Amazon Web Services sends the notification, and waits 14 calendar days
	//   to retire the tasks.
	//
	// This member is required.
	Value *string
	// contains filtered or unexported fields
}

type PutAccountSettingDefaultOutput struct {

	// The current setting for a resource.
	Setting *types.Setting

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type PutAccountSettingInput struct {

	// The Amazon ECS account setting name to modify. The following are the valid
	// values for the account setting name.
	//   - serviceLongArnFormat - When modified, the Amazon Resource Name (ARN) and
	//   resource ID format of the resource type for a specified user, role, or the root
	//   user for an account is affected. The opt-in and opt-out account setting must be
	//   set for each Amazon ECS resource separately. The ARN and resource ID format of a
	//   resource is defined by the opt-in status of the user or role that created the
	//   resource. You must turn on this setting to use Amazon ECS features such as
	//   resource tagging.
	//   - taskLongArnFormat - When modified, the Amazon Resource Name (ARN) and
	//   resource ID format of the resource type for a specified user, role, or the root
	//   user for an account is affected. The opt-in and opt-out account setting must be
	//   set for each Amazon ECS resource separately. The ARN and resource ID format of a
	//   resource is defined by the opt-in status of the user or role that created the
	//   resource. You must turn on this setting to use Amazon ECS features such as
	//   resource tagging.
	//   - containerInstanceLongArnFormat - When modified, the Amazon Resource Name
	//   (ARN) and resource ID format of the resource type for a specified user, role, or
	//   the root user for an account is affected. The opt-in and opt-out account setting
	//   must be set for each Amazon ECS resource separately. The ARN and resource ID
	//   format of a resource is defined by the opt-in status of the user or role that
	//   created the resource. You must turn on this setting to use Amazon ECS features
	//   such as resource tagging.
	//   - awsvpcTrunking - When modified, the elastic network interface (ENI) limit
	//   for any new container instances that support the feature is changed. If
	//   awsvpcTrunking is turned on, any new container instances that support the
	//   feature are launched have the increased ENI limits available to them. For more
	//   information, see Elastic Network Interface Trunking (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html)
	//   in the Amazon Elastic Container Service Developer Guide.
	//   - containerInsights - When modified, the default setting indicating whether
	//   Amazon Web Services CloudWatch Container Insights is turned on for your clusters
	//   is changed. If containerInsights is turned on, any new clusters that are
	//   created will have Container Insights turned on unless you disable it during
	//   cluster creation. For more information, see CloudWatch Container Insights (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-container-insights.html)
	//   in the Amazon Elastic Container Service Developer Guide.
	//   - dualStackIPv6 - When turned on, when using a VPC in dual stack mode, your
	//   tasks using the awsvpc network mode can have an IPv6 address assigned. For
	//   more information on using IPv6 with tasks launched on Amazon EC2 instances, see
	//   Using a VPC in dual-stack mode (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking-awsvpc.html#task-networking-vpc-dual-stack)
	//   . For more information on using IPv6 with tasks launched on Fargate, see
	//   Using a VPC in dual-stack mode (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-task-networking.html#fargate-task-networking-vpc-dual-stack)
	//   .
	//   - fargateFIPSMode - If you specify fargateFIPSMode , Fargate FIPS 140
	//   compliance is affected.
	//   - fargateTaskRetirementWaitPeriod - When Amazon Web Services determines that a
	//   security or infrastructure update is needed for an Amazon ECS task hosted on
	//   Fargate, the tasks need to be stopped and new tasks launched to replace them.
	//   Use fargateTaskRetirementWaitPeriod to configure the wait time to retire a
	//   Fargate task. For information about the Fargate tasks maintenance, see Amazon
	//   Web Services Fargate task maintenance (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-maintenance.html)
	//   in the Amazon ECS Developer Guide.
	//   - tagResourceAuthorization - Amazon ECS is introducing tagging authorization
	//   for resource creation. Users must have permissions for actions that create the
	//   resource, such as ecsCreateCluster . If tags are specified when you create a
	//   resource, Amazon Web Services performs additional authorization to verify if
	//   users or roles have permissions to create tags. Therefore, you must grant
	//   explicit permissions to use the ecs:TagResource action. For more information,
	//   see Grant permission to tag resources on creation (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/supported-iam-actions-tagging.html)
	//   in the Amazon ECS Developer Guide.
	//   - guardDutyActivate - The guardDutyActivate parameter is read-only in Amazon
	//   ECS and indicates whether Amazon ECS Runtime Monitoring is enabled or disabled
	//   by your security administrator in your Amazon ECS account. Amazon GuardDuty
	//   controls this account setting on your behalf. For more information, see
	//   Protecting Amazon ECS workloads with Amazon ECS Runtime Monitoring (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-guard-duty-integration.html)
	//   .
	//
	// This member is required.
	Name types.SettingName

	// The account setting value for the specified principal ARN. Accepted values are
	// enabled , disabled , on , and off . When you specify
	// fargateTaskRetirementWaitPeriod for the name , the following are the valid
	// values:
	//   - 0 - Amazon Web Services sends the notification, and immediately retires the
	//   affected tasks.
	//   - 7 - Amazon Web Services sends the notification, and waits 7 calendar days to
	//   retire the tasks.
	//   - 14 - Amazon Web Services sends the notification, and waits 14 calendar days
	//   to retire the tasks.
	//
	// This member is required.
	Value *string

	// The ARN of the principal, which can be a user, role, or the root user. If you
	// specify the root user, it modifies the account setting for all users, roles, and
	// the root user of the account unless a user or role explicitly overrides these
	// settings. If this field is omitted, the setting is changed only for the
	// authenticated user. You must use the root user when you set the Fargate wait
	// time ( fargateTaskRetirementWaitPeriod ). Federated users assume the account
	// setting of the root user and can't have explicit account settings set for them.
	PrincipalArn *string
	// contains filtered or unexported fields
}

type PutAccountSettingOutput struct {

	// The current account setting for a resource.
	Setting *types.Setting

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type PutAttributesInput struct {

	// The attributes to apply to your resource. You can specify up to 10 custom
	// attributes for each resource. You can specify up to 10 attributes in a single
	// call.
	//
	// This member is required.
	Attributes []types.Attribute

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

type PutAttributesOutput struct {

	// The attributes applied to your resource.
	Attributes []types.Attribute

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type PutClusterCapacityProvidersInput struct {

	// 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 Fargate capacity provider,
	// specify either the FARGATE or FARGATE_SPOT capacity providers. The Fargate
	// capacity providers are available to all accounts and only need to be associated
	// with a cluster to be used.
	//
	// This member is required.
	CapacityProviders []string

	// The short name or full Amazon Resource Name (ARN) of the cluster to modify the
	// capacity provider settings for. If you don't specify a cluster, the default
	// cluster is assumed.
	//
	// This member is required.
	Cluster *string

	// 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 Fargate capacity provider,
	// specify either the FARGATE or FARGATE_SPOT capacity providers. The Fargate
	// capacity providers are available to all accounts and only need to be associated
	// with a cluster to be used.
	//
	// This member is required.
	DefaultCapacityProviderStrategy []types.CapacityProviderStrategyItem
	// contains filtered or unexported fields
}

type PutClusterCapacityProvidersOutput struct {

	// Details about the cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type RegisterContainerInstanceInput struct {

	// The container instance attributes that this container instance supports.
	Attributes []types.Attribute

	// The short name or full Amazon Resource Name (ARN) of the cluster to register
	// your container instance with. If you do not specify a cluster, the default
	// cluster is assumed.
	Cluster *string

	// The ARN of the container instance (if it was previously registered).
	ContainerInstanceArn *string

	// 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 devices that are available on the container instance. The only supported
	// device type is a GPU.
	PlatformDevices []types.PlatformDevice

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

	// The resources available on the instance.
	TotalResources []types.Resource

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

type RegisterContainerInstanceOutput struct {

	// The container instance that was registered.
	ContainerInstance *types.ContainerInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type RegisterTaskDefinitionInput struct {

	// A list of container definitions in JSON format that describe the different
	// containers that make up your task.
	//
	// This member is required.
	ContainerDefinitions []types.ContainerDefinition

	// You must specify a family for a task definition. You can use it 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,
	// underscores, and hyphens are allowed.
	//
	// This member is required.
	Family *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're 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 do not specify a
	// value, the parameter is ignored. If you're 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: The CPU units cannot
	// be less than 1 vCPU when you use Windows containers on Fargate.
	//   - 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2
	//   GB)
	//   - 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3
	//   GB), 4096 (4 GB)
	//   - 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4
	//   GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
	//   - 2048 (2 vCPU) - Available memory values: 4096 (4 GB) and 16384 (16 GB) in
	//   increments of 1024 (1 GB)
	//   - 4096 (4 vCPU) - Available memory values: 8192 (8 GB) and 30720 (30 GB) in
	//   increments of 1024 (1 GB)
	//   - 8192 (8 vCPU) - Available memory values: 16 GB and 60 GB in 4 GB increments
	//   This option requires Linux platform 1.4.0 or later.
	//   - 16384 (16vCPU) - Available memory values: 32GB and 120 GB in 8 GB increments
	//   This option requires Linux platform 1.4.0 or later.
	Cpu *string

	// The amount of ephemeral storage to allocate for the task. This parameter is
	// used to expand the total amount of ephemeral storage available, beyond the
	// default amount, for tasks hosted on Fargate. For more information, see Using
	// data volumes in tasks (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html)
	// in the Amazon ECS Developer Guide. For tasks using the Fargate launch type, the
	// task requires the following platforms:
	//   - Linux platform version 1.4.0 or later.
	//   - Windows platform version 1.0.0 or later.
	EphemeralStorage *types.EphemeralStorage

	// The Amazon Resource Name (ARN) of the task execution role that grants the
	// Amazon ECS container agent permission to make Amazon Web Services 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 Elastic Inference accelerators to use for the containers in the task.
	InferenceAccelerators []types.InferenceAccelerator

	// 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 run on Fargate.
	IpcMode types.IpcMode

	// 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. This determines your range of
	// supported values for the cpu parameter. The CPU units cannot be less than 1
	// vCPU when you use Windows containers on Fargate.
	//   - 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25
	//   vCPU)
	//   - 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values:
	//   512 (.5 vCPU)
	//   - 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7
	//   GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU)
	//   - Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) -
	//   Available cpu values: 2048 (2 vCPU)
	//   - Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) -
	//   Available cpu values: 4096 (4 vCPU)
	//   - Between 16 GB and 60 GB in 4 GB increments - Available cpu values: 8192 (8
	//   vCPU) This option requires Linux platform 1.4.0 or later.
	//   - Between 32GB and 120 GB in 8 GB increments - Available cpu values: 16384 (16
	//   vCPU) This option requires Linux platform 1.4.0 or later.
	Memory *string

	// The Docker networking mode to use for the containers in the task. The valid
	// values are none , bridge , awsvpc , and host . If no network mode is specified,
	// the default is bridge . For Amazon ECS tasks on Fargate, the awsvpc network
	// mode is required. For Amazon ECS tasks on Amazon EC2 Linux instances, any
	// network mode can be used. For Amazon ECS tasks on Amazon EC2 Windows instances,
	// or awsvpc 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. When using the host network mode, you
	// should not run containers using the root user (UID 0). It is considered best
	// practice to use a non-root user. 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. 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. For more information, see
	// Network settings (https://docs.docker.com/engine/reference/run/#network-settings)
	// in the Docker run reference.
	NetworkMode types.NetworkMode

	// The process namespace to use for the containers in the task. The valid values
	// are host or task . On Fargate for Linux containers, the only valid value is task
	// . For example, monitoring sidecars might need pidMode to access information
	// about other containers running in the same task. If host is specified, all
	// containers within the tasks that specified the host PID mode on the same
	// container instance share the 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 each container. 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, there's a heightened
	// risk of undesired process namespace exposure. For more information, see Docker
	// security (https://docs.docker.com/engine/security/security/) . This parameter is
	// not supported for Windows containers. This parameter is only supported for tasks
	// that are hosted on Fargate if the tasks are using platform version 1.4.0 or
	// later (Linux). This isn't supported for Windows containers on Fargate.
	PidMode types.PidMode

	// An array of placement constraint objects to use for the task. You can specify a
	// maximum of 10 constraints for each task. This limit includes constraints in the
	// task definition and those specified at runtime.
	PlacementConstraints []types.TaskDefinitionPlacementConstraint

	// The configuration details for the App Mesh proxy. For tasks hosted on Amazon
	// EC2 instances, 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 use 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 AMI versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-ami-versions.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ProxyConfiguration *types.ProxyConfiguration

	// The task launch type that Amazon ECS validates the task definition against. A
	// client exception is returned if the task definition doesn't validate against the
	// compatibilities specified. If no value is specified, the parameter is omitted
	// from the response.
	RequiresCompatibilities []types.Compatibility

	// The operating system that your tasks definitions run on. A platform family is
	// specified only for tasks using the Fargate launch type. When you specify a task
	// definition in a service, this value must match the runtimePlatform value of the
	// service.
	RuntimePlatform *types.RuntimePlatform

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

	// 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

	// A list of volume definitions in JSON format that containers in your task might
	// use.
	Volumes []types.Volume
	// contains filtered or unexported fields
}

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

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  EndpointResolverOptions
}

type RunTaskInput struct {

	// The family and revision ( family:revision ) or full ARN of the task definition
	// to run. If a revision isn't specified, the latest ACTIVE revision is used. The
	// full ARN value must match the value that you specified as the Resource of the
	// principal's permissions policy. When you specify a task definition, you must
	// either specify a specific revision, or all revisions in the ARN. To specify a
	// specific revision, include the revision number in the ARN. For example, to
	// specify revision 2, use
	// arn:aws:ecs:us-east-1:111122223333:task-definition/TaskFamilyName:2 . To specify
	// all revisions, use the wildcard (*) in the ARN. For example, to specify all
	// revisions, use
	// arn:aws:ecs:us-east-1:111122223333:task-definition/TaskFamilyName:* . For more
	// information, see Policy Resources for Amazon ECS (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-resources)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	// This member is required.
	TaskDefinition *string

	// The capacity provider strategy to use for the task. 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. When you use cluster
	// auto scaling, you must specify capacityProviderStrategy and not launchType . A
	// capacity provider strategy may contain a maximum of 6 capacity providers.
	CapacityProviderStrategy []types.CapacityProviderStrategyItem

	// An identifier that you provide to ensure the idempotency of the request. It
	// must be unique and is case sensitive. Up to 64 characters are allowed. The valid
	// characters are characters in the range of 33-126, inclusive. For more
	// information, see Ensuring idempotency (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/ECS_Idempotency.html)
	// .
	ClientToken *string

	// The short name or full Amazon Resource Name (ARN) of the cluster to run your
	// task on. If you do not specify a cluster, the default cluster is assumed.
	Cluster *string

	// The number of instantiations of the specified task to place on your cluster.
	// You can specify up to 10 tasks for each call.
	Count *int32

	// Specifies whether to use 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

	// Determines whether to use the execute command functionality for the containers
	// in this task. If true , this enables execute command functionality on all
	// containers in the task. If true , then the task definition must have a task
	// role, or you must provide one as an override.
	EnableExecuteCommand bool

	// 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 infrastructure to run your standalone task on. For more information, see
	// Amazon ECS launch types (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
	// in the Amazon Elastic Container Service Developer Guide. The FARGATE launch
	// type runs your tasks on Fargate On-Demand infrastructure. Fargate Spot
	// infrastructure is available for use but a capacity provider strategy must be
	// used. For more information, see Fargate capacity providers (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-capacity-providers.html)
	// in the Amazon ECS Developer Guide. The EC2 launch type runs your tasks on
	// Amazon EC2 instances registered to your cluster. The EXTERNAL launch type runs
	// your tasks on your on-premises server or virtual machine (VM) capacity
	// registered to your cluster. A task can use either a launch type or a capacity
	// provider strategy. If a launchType is specified, the capacityProviderStrategy
	// parameter must be omitted. When you use cluster auto scaling, you must specify
	// capacityProviderStrategy and not launchType .
	LaunchType types.LaunchType

	// 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 isn't 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

	// 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's 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

	// An array of placement constraint objects to use for the task. You can specify
	// up to 10 constraints for each task (including constraints in the task definition
	// and those specified at runtime).
	PlacementConstraints []types.PlacementConstraint

	// The placement strategy objects to use for the task. You can specify a maximum
	// of 5 strategy rules for each task.
	PlacementStrategy []types.PlacementStrategy

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

	// Specifies whether to propagate the tags from the task definition to the task.
	// If no value is specified, the tags aren't 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

	// The reference ID to use for the task. The reference ID can have a maximum
	// length of 1024 characters.
	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 128 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 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 Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	Tags []types.Tag

	// The details of the volume that was configuredAtLaunch . You can configure the
	// size, volumeType, IOPS, throughput, snapshot and encryption in in
	// TaskManagedEBSVolumeConfiguration (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TaskManagedEBSVolumeConfiguration.html)
	// . The name of the volume must match the name from the task definition.
	VolumeConfigurations []types.TaskVolumeConfiguration
	// contains filtered or unexported fields
}

type RunTaskOutput struct {

	// Any failures associated with the call. For information about how to address
	// failures, see Service event messages (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html#service-event-messages-list)
	// and API failure reasons (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Failures []types.Failure

	// A full description of the tasks that were run. The tasks that were successfully
	// placed on your cluster are described here.
	Tasks []types.Task

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ServicesInactiveWaiterOptions 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.
	//
	// Passing options here is functionally equivalent to passing values to this
	// config's ClientOptions field that extend the inner client's APIOptions directly.
	APIOptions []func(*middleware.Stack) error

	// Functional options to be passed to all operations invoked by this client.
	//
	// Function values that modify the inner APIOptions are applied after the waiter
	// config's own APIOptions modifiers.
	ClientOptions []func(*Options)

	// MinDelay is the minimum amount of time to delay between retries. If unset,
	// ServicesInactiveWaiter will use default minimum delay of 15 seconds. Note that
	// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
	MinDelay time.Duration

	// MaxDelay is the maximum amount of time to delay between retries. If unset or
	// set to zero, ServicesInactiveWaiter will use default max delay of 120 seconds.
	// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
	MaxDelay time.Duration

	// LogWaitAttempts is used to enable logging for waiter retry attempts
	LogWaitAttempts bool

	// Retryable is function that can be used to override the service defined
	// waiter-behavior based on operation output, or returned error. This function is
	// used by the waiter to decide if a state is retryable or a terminal state. By
	// default service-modeled logic will populate this option. This option can thus be
	// used to define a custom waiter state with fall-back to service-modeled waiter
	// state mutators.The function returns an error in case of a failure state. In case
	// of retry state, this function returns a bool value of true and nil error, while
	// in case of success it returns a bool value of false and nil error.
	Retryable func(context.Context, *DescribeServicesInput, *DescribeServicesOutput, error) (bool, error)
}

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

type ServicesStableWaiterOptions 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.
	//
	// Passing options here is functionally equivalent to passing values to this
	// config's ClientOptions field that extend the inner client's APIOptions directly.
	APIOptions []func(*middleware.Stack) error

	// Functional options to be passed to all operations invoked by this client.
	//
	// Function values that modify the inner APIOptions are applied after the waiter
	// config's own APIOptions modifiers.
	ClientOptions []func(*Options)

	// MinDelay is the minimum amount of time to delay between retries. If unset,
	// ServicesStableWaiter will use default minimum delay of 15 seconds. Note that
	// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
	MinDelay time.Duration

	// MaxDelay is the maximum amount of time to delay between retries. If unset or
	// set to zero, ServicesStableWaiter will use default max delay of 120 seconds.
	// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
	MaxDelay time.Duration

	// LogWaitAttempts is used to enable logging for waiter retry attempts
	LogWaitAttempts bool

	// Retryable is function that can be used to override the service defined
	// waiter-behavior based on operation output, or returned error. This function is
	// used by the waiter to decide if a state is retryable or a terminal state. By
	// default service-modeled logic will populate this option. This option can thus be
	// used to define a custom waiter state with fall-back to service-modeled waiter
	// state mutators.The function returns an error in case of a failure state. In case
	// of retry state, this function returns a bool value of true and nil error, while
	// in case of success it returns a bool value of false and nil error.
	Retryable func(context.Context, *DescribeServicesInput, *DescribeServicesOutput, error) (bool, error)
}

type StartTaskInput struct {

	// The container instance IDs or full ARN entries for the container instances
	// where you would like to place your task. You can specify up to 10 container
	// instances.
	//
	// This member is required.
	ContainerInstances []string

	// The family and revision ( family:revision ) or full ARN of the task definition
	// to start. If a revision isn't specified, the latest ACTIVE revision is used.
	//
	// This member is required.
	TaskDefinition *string

	// The short name or full Amazon Resource Name (ARN) of the cluster where to start
	// your task. If you do not specify a cluster, the default cluster is assumed.
	Cluster *string

	// Specifies whether to use 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

	// Whether or not the execute command functionality is turned on for the task. If
	// true , this turns on the execute command functionality on all containers in the
	// task.
	EnableExecuteCommand bool

	// 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 VPC subnet and security group configuration for tasks that receive their
	// own elastic network interface by using the awsvpc networking mode.
	NetworkConfiguration *types.NetworkConfiguration

	// A list of container overrides in JSON format that specify the name of a
	// container in the specified task definition and the overrides it receives. You
	// can override the default command for a container (that's 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

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

	// 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, the startedBy parameter contains the
	// deployment ID of the service that starts it.
	StartedBy *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 Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	Tags []types.Tag

	// The details of the volume that was configuredAtLaunch . You can configure the
	// size, volumeType, IOPS, throughput, snapshot and encryption in
	// TaskManagedEBSVolumeConfiguration (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TaskManagedEBSVolumeConfiguration.html)
	// . The name of the volume must match the name from the task definition.
	VolumeConfigurations []types.TaskVolumeConfiguration
	// contains filtered or unexported fields
}

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

type StopTaskInput struct {

	// The task ID of the task to stop.
	//
	// This member is required.
	Task *string

	// 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

	// An optional message specified when a task is stopped. For example, if you're
	// 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.
	Reason *string
	// contains filtered or unexported fields
}

type StopTaskOutput struct {

	// The task that was stopped.
	Task *types.Task

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type SubmitAttachmentStateChangesInput struct {

	// Any attachments associated with the state change request.
	//
	// This member is required.
	Attachments []types.AttachmentStateChange

	// The short name or full ARN of the cluster that hosts the container instance the
	// attachment belongs to.
	Cluster *string
	// contains filtered or unexported fields
}

type SubmitAttachmentStateChangesOutput struct {

	// Acknowledgement of the state change.
	Acknowledgment *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type SubmitContainerStateChangeInput struct {

	// The short name or full ARN of the cluster that hosts the container.
	Cluster *string

	// The name of the container.
	ContainerName *string

	// The exit code that's returned for the state change request.
	ExitCode *int32

	// The network bindings of the container.
	NetworkBindings []types.NetworkBinding

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

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

	// The status of the state change request.
	Status *string

	// The task ID or full Amazon Resource Name (ARN) of the task that hosts the
	// container.
	Task *string
	// contains filtered or unexported fields
}

type SubmitContainerStateChangeOutput struct {

	// Acknowledgement of the state change.
	Acknowledgment *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type SubmitTaskStateChangeInput struct {

	// Any attachments associated with the state change request.
	Attachments []types.AttachmentStateChange

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// task.
	Cluster *string

	// Any containers that's associated with the state change request.
	Containers []types.ContainerStateChange

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

	// The details for the managed agent that's associated with the task.
	ManagedAgents []types.ManagedAgentStateChange

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

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

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

	// The status of the state change request.
	Status *string

	// The task ID or full ARN of the task in the state change request.
	Task *string
	// contains filtered or unexported fields
}

type SubmitTaskStateChangeOutput struct {

	// Acknowledgement of the state change.
	Acknowledgment *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type TagResourceInput struct {

	// The Amazon Resource Name (ARN) of the resource to add tags to. Currently, the
	// supported resources are Amazon ECS capacity providers, tasks, services, task
	// definitions, clusters, and container instances.
	//
	// This member is required.
	ResourceArn *string

	// 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 Amazon Web Services use.
	//   You cannot edit or delete tag keys or values with this prefix. Tags with this
	//   prefix do not count against your tags per resource limit.
	//
	// This member is required.
	Tags []types.Tag
	// contains filtered or unexported fields
}

type TagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type TasksRunningWaiterOptions 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.
	//
	// Passing options here is functionally equivalent to passing values to this
	// config's ClientOptions field that extend the inner client's APIOptions directly.
	APIOptions []func(*middleware.Stack) error

	// Functional options to be passed to all operations invoked by this client.
	//
	// Function values that modify the inner APIOptions are applied after the waiter
	// config's own APIOptions modifiers.
	ClientOptions []func(*Options)

	// MinDelay is the minimum amount of time to delay between retries. If unset,
	// TasksRunningWaiter will use default minimum delay of 6 seconds. Note that
	// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
	MinDelay time.Duration

	// MaxDelay is the maximum amount of time to delay between retries. If unset or
	// set to zero, TasksRunningWaiter will use default max delay of 120 seconds. Note
	// that MaxDelay must resolve to value greater than or equal to the MinDelay.
	MaxDelay time.Duration

	// LogWaitAttempts is used to enable logging for waiter retry attempts
	LogWaitAttempts bool

	// Retryable is function that can be used to override the service defined
	// waiter-behavior based on operation output, or returned error. This function is
	// used by the waiter to decide if a state is retryable or a terminal state. By
	// default service-modeled logic will populate this option. This option can thus be
	// used to define a custom waiter state with fall-back to service-modeled waiter
	// state mutators.The function returns an error in case of a failure state. In case
	// of retry state, this function returns a bool value of true and nil error, while
	// in case of success it returns a bool value of false and nil error.
	Retryable func(context.Context, *DescribeTasksInput, *DescribeTasksOutput, error) (bool, error)
}

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

type TasksStoppedWaiterOptions 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.
	//
	// Passing options here is functionally equivalent to passing values to this
	// config's ClientOptions field that extend the inner client's APIOptions directly.
	APIOptions []func(*middleware.Stack) error

	// Functional options to be passed to all operations invoked by this client.
	//
	// Function values that modify the inner APIOptions are applied after the waiter
	// config's own APIOptions modifiers.
	ClientOptions []func(*Options)

	// MinDelay is the minimum amount of time to delay between retries. If unset,
	// TasksStoppedWaiter will use default minimum delay of 6 seconds. Note that
	// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
	MinDelay time.Duration

	// MaxDelay is the maximum amount of time to delay between retries. If unset or
	// set to zero, TasksStoppedWaiter will use default max delay of 120 seconds. Note
	// that MaxDelay must resolve to value greater than or equal to the MinDelay.
	MaxDelay time.Duration

	// LogWaitAttempts is used to enable logging for waiter retry attempts
	LogWaitAttempts bool

	// Retryable is function that can be used to override the service defined
	// waiter-behavior based on operation output, or returned error. This function is
	// used by the waiter to decide if a state is retryable or a terminal state. By
	// default service-modeled logic will populate this option. This option can thus be
	// used to define a custom waiter state with fall-back to service-modeled waiter
	// state mutators.The function returns an error in case of a failure state. In case
	// of retry state, this function returns a bool value of true and nil error, while
	// in case of success it returns a bool value of false and nil error.
	Retryable func(context.Context, *DescribeTasksInput, *DescribeTasksOutput, error) (bool, error)
}

type UntagResourceInput struct {

	// The Amazon Resource Name (ARN) of the resource to delete tags from. Currently,
	// the supported resources are Amazon ECS capacity providers, tasks, services, task
	// definitions, clusters, and container instances.
	//
	// This member is required.
	ResourceArn *string

	// The keys of the tags to be removed.
	//
	// This member is required.
	TagKeys []string
	// contains filtered or unexported fields
}

type UntagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateCapacityProviderInput struct {

	// An object that represent the parameters to update for the Auto Scaling group
	// capacity provider.
	//
	// This member is required.
	AutoScalingGroupProvider *types.AutoScalingGroupProviderUpdate

	// The name of the capacity provider to update.
	//
	// This member is required.
	Name *string
	// contains filtered or unexported fields
}

type UpdateCapacityProviderOutput struct {

	// Details about the capacity provider.
	CapacityProvider *types.CapacityProvider

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateClusterInput struct {

	// The name of the cluster to modify the settings for.
	//
	// This member is required.
	Cluster *string

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

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

	// The cluster settings for your cluster.
	Settings []types.ClusterSetting
	// contains filtered or unexported fields
}

type UpdateClusterOutput struct {

	// Details about the cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateClusterSettingsInput struct {

	// The name of the cluster to modify the settings for.
	//
	// This member is required.
	Cluster *string

	// The setting to use by default for a cluster. This parameter is used to turn on
	// CloudWatch Container Insights for a cluster. If this value is specified, it
	// overrides the containerInsights value set with PutAccountSetting or
	// PutAccountSettingDefault . Currently, if you delete an existing cluster that
	// does not have Container Insights turned on, and then create a new cluster with
	// the same name with Container Insights tuned on, Container Insights will not
	// actually be turned on. If you want to preserve the same name for your existing
	// cluster and turn on Container Insights, you must wait 7 days before you can
	// re-create it.
	//
	// This member is required.
	Settings []types.ClusterSetting
	// contains filtered or unexported fields
}

type UpdateClusterSettingsOutput struct {

	// Details about the cluster
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateContainerAgentInput struct {

	// The container instance ID or full ARN entries for the container instance where
	// you would like to update the Amazon ECS container agent.
	//
	// This member is required.
	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
	// contains filtered or unexported fields
}

type UpdateContainerAgentOutput struct {

	// The container instance that the container agent was updated for.
	ContainerInstance *types.ContainerInstance

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateContainerInstancesStateInput struct {

	// A list of up to 10 container instance IDs or full ARN entries.
	//
	// This member is required.
	ContainerInstances []string

	// The container instance state to update the container instance with. 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 can't update the container
	// instance state.
	//
	// This member is required.
	Status types.ContainerInstanceStatus

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

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

type UpdateServiceInput struct {

	// The name of the service to update.
	//
	// This member is required.
	Service *string

	// The capacity provider strategy to update the service to use. if the service
	// uses 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's not the default capacity provider strategy, the service can't 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 Fargate capacity provider,
	// specify either the FARGATE or FARGATE_SPOT capacity providers. The 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 short name or full Amazon Resource Name (ARN) of the cluster that your
	// service runs on. If you do not specify a cluster, the default cluster is
	// assumed.
	Cluster *string

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

	// The number of instantiations of the task to place and keep running in your
	// service.
	DesiredCount *int32

	// Determines whether to turn on Amazon ECS managed tags for the tasks in the
	// service. For more information, see Tagging Your Amazon ECS Resources (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html)
	// in the Amazon Elastic Container Service Developer Guide. Only tasks launched
	// after the update will reflect the update. To update the tags on all tasks, set
	// forceNewDeployment to true , so that Amazon ECS starts new tasks with the
	// updated tags.
	EnableECSManagedTags *bool

	// If true , this enables execute command functionality on all task containers. If
	// you do not want to override the value that was set when the service was created,
	// you can set this to null when performing this action.
	EnableExecuteCommand *bool

	// Determines whether to force a new deployment of the service. By default,
	// deployments aren't forced. You can use this option to start 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

	// The period of time, in seconds, that the Amazon ECS service scheduler ignores
	// unhealthy Elastic Load Balancing target health checks after a task has first
	// started. 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

	// A list of Elastic Load Balancing load balancer objects. It contains the load
	// balancer name, the container name, and the container port to access from the
	// load balancer. The container name is as it appears in a container definition.
	// When you add, update, or remove a load balancer configuration, Amazon ECS starts
	// new tasks with the updated Elastic Load Balancing configuration, and then stops
	// the old tasks when the new tasks are running. For services that use rolling
	// updates, you can add, update, or remove Elastic Load Balancing target groups.
	// You can update from a single target group to multiple target groups and from
	// multiple target groups to a single target group. For services that use
	// blue/green deployments, you can update Elastic Load Balancing target groups by
	// using CreateDeployment (https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html)
	// through CodeDeploy. Note that multiple target groups are not supported for
	// blue/green deployments. For more information see Register multiple target
	// groups with a service (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html)
	// in the Amazon Elastic Container Service Developer Guide. For services that use
	// the external deployment controller, you can add, update, or remove load
	// balancers by using CreateTaskSet (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateTaskSet.html)
	// . Note that multiple target groups are not supported for external deployments.
	// For more information see Register multiple target groups with a service (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html)
	// in the Amazon Elastic Container Service Developer Guide. You can remove existing
	// loadBalancers by passing an empty list.
	LoadBalancers []types.LoadBalancer

	// An object representing the network configuration for the service.
	NetworkConfiguration *types.NetworkConfiguration

	// 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
	// for each task. This limit includes constraints in the task definition and those
	// specified at runtime.
	PlacementConstraints []types.PlacementConstraint

	// 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 for
	// each service.
	PlacementStrategy []types.PlacementStrategy

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

	// Determines whether to propagate the tags from the task definition or the
	// service to the task. If no value is specified, the tags aren't propagated. Only
	// tasks launched after the update will reflect the update. To update the tags on
	// all tasks, set forceNewDeployment to true , so that Amazon ECS starts new tasks
	// with the updated tags.
	PropagateTags types.PropagateTags

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

	// The details for the service discovery registries to assign to this service. For
	// more information, see Service Discovery (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html)
	// . When you add, update, or remove the service registries configuration, Amazon
	// ECS starts new tasks with the updated service registries configuration, and then
	// stops the old tasks when the new tasks are running. You can remove existing
	// serviceRegistries by passing an empty list.
	ServiceRegistries []types.ServiceRegistry

	// 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 details of the volume that was configuredAtLaunch . You can configure the
	// size, volumeType, IOPS, throughput, snapshot and encryption in
	// ServiceManagedEBSVolumeConfiguration (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ServiceManagedEBSVolumeConfiguration.html)
	// . The name of the volume must match the name from the task definition. If set
	// to null, no new deployment is triggered. Otherwise, if this configuration
	// differs from the existing one, it triggers a new deployment.
	VolumeConfigurations []types.ServiceVolumeConfiguration
	// contains filtered or unexported fields
}

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

type UpdateServicePrimaryTaskSetInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task set exists in.
	//
	// This member is required.
	Cluster *string

	// The short name or full Amazon Resource Name (ARN) of the task set to set as the
	// primary task set in the deployment.
	//
	// This member is required.
	PrimaryTaskSet *string

	// The short name or full Amazon Resource Name (ARN) of the service that the task
	// set exists in.
	//
	// This member is required.
	Service *string
	// contains filtered or unexported fields
}

type UpdateServicePrimaryTaskSetOutput struct {

	// The details about the task set.
	TaskSet *types.TaskSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateTaskProtectionInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task sets exist in.
	//
	// This member is required.
	Cluster *string

	// Specify true to mark a task for protection and false to unset protection,
	// making it eligible for termination.
	//
	// This member is required.
	ProtectionEnabled bool

	// A list of up to 10 task IDs or full ARN entries.
	//
	// This member is required.
	Tasks []string

	// If you set protectionEnabled to true , you can specify the duration for task
	// protection in minutes. You can specify a value from 1 minute to up to 2,880
	// minutes (48 hours). During this time, your task will not be terminated by
	// scale-in events from Service Auto Scaling or deployments. After this time period
	// lapses, protectionEnabled will be reset to false . If you don’t specify the
	// time, then the task is automatically protected for 120 minutes (2 hours).
	ExpiresInMinutes *int32
	// contains filtered or unexported fields
}

type UpdateTaskProtectionOutput struct {

	// Any failures associated with the call.
	Failures []types.Failure

	// A list of tasks with the following information.
	//   - taskArn : The task ARN.
	//   - protectionEnabled : The protection status of the task. If scale-in
	//   protection is turned on for a task, the value is true . Otherwise, it is false
	//   .
	//   - expirationDate : The epoch time when protection for the task will expire.
	ProtectedTasks []types.ProtectedTask

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateTaskSetInput struct {

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the
	// service that the task set is found in.
	//
	// This member is required.
	Cluster *string

	// A floating-point percentage of the desired number of tasks to place and keep
	// running in the task set.
	//
	// This member is required.
	Scale *types.Scale

	// The short name or full Amazon Resource Name (ARN) of the service that the task
	// set is found in.
	//
	// This member is required.
	Service *string

	// The short name or full Amazon Resource Name (ARN) of the task set to update.
	//
	// This member is required.
	TaskSet *string
	// contains filtered or unexported fields
}

type UpdateTaskSetOutput struct {

	// Details about the task set.
	TaskSet *types.TaskSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}