// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateCapacityProviderInputBody<'a> {
    /// <p>The name of the capacity provider. Up to 255 characters are allowed, including letters
    /// (upper and lowercase), numbers, underscores, and hyphens. The name cannot be prefixed
    /// with "<code>aws</code>", "<code>ecs</code>", or "<code>fargate</code>".</p>
    pub name: &'a std::option::Option<std::string::String>,
    /// <p>The details of the Auto Scaling group for the capacity provider.</p>
    pub auto_scaling_group_provider:
        &'a std::option::Option<crate::model::AutoScalingGroupProvider>,
    /// <p>The metadata that you apply to the capacity provider to help you categorize and
    /// organize them. Each tag consists of a key and an optional value, both of which you
    /// define.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl<'a> std::fmt::Debug for CreateCapacityProviderInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateCapacityProviderInputBody");
        formatter.field("name", &self.name);
        formatter.field(
            "auto_scaling_group_provider",
            &self.auto_scaling_group_provider,
        );
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateClusterInputBody<'a> {
    /// <p>The name of your cluster. If you do not specify a name for your cluster, you create a
    /// cluster named <code>default</code>. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. </p>
    pub cluster_name: &'a std::option::Option<std::string::String>,
    /// <p>The metadata that you apply to the cluster to help you categorize and organize them.
    /// Each tag consists of a key and an optional value, both of which you define.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>The setting to use when creating a cluster. This parameter is used to enable CloudWatch
    /// Container Insights for a cluster. If this value is specified, it will override the
    /// <code>containerInsights</code> value set with <a>PutAccountSetting</a> or
    /// <a>PutAccountSettingDefault</a>.</p>
    pub settings: &'a std::option::Option<std::vec::Vec<crate::model::ClusterSetting>>,
    /// <p>The execute command configuration for the cluster.</p>
    pub configuration: &'a std::option::Option<crate::model::ClusterConfiguration>,
    /// <p>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 <a>CreateService</a> or <a>RunTask</a>
    /// actions.</p>
    /// <p>If specifying a capacity provider that uses an Auto Scaling group, the capacity
    /// provider must already be created and not already associated with another cluster. New
    /// Auto Scaling group capacity providers can be created with the <a>CreateCapacityProvider</a> API operation.</p>
    /// <p>To use a AWS Fargate capacity provider, specify either the <code>FARGATE</code> or
    /// <code>FARGATE_SPOT</code> capacity providers. The AWS Fargate capacity providers are
    /// available to all accounts and only need to be associated with a cluster to be
    /// used.</p>
    /// <p>The <a>PutClusterCapacityProviders</a> API operation is used to update the
    /// list of available capacity providers for a cluster after the cluster is created.</p>
    pub capacity_providers: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The capacity provider strategy to set as the default for the cluster. When a default
    /// capacity provider strategy is set for a cluster, when calling the <a>RunTask</a> or <a>CreateService</a> APIs wtih no capacity
    /// provider strategy or launch type specified, the default capacity provider strategy for
    /// the cluster is used.</p>
    /// <p>If a default capacity provider strategy is not defined for a cluster during creation,
    /// it can be defined later with the <a>PutClusterCapacityProviders</a> API
    /// operation.</p>
    pub default_capacity_provider_strategy:
        &'a std::option::Option<std::vec::Vec<crate::model::CapacityProviderStrategyItem>>,
}
impl<'a> std::fmt::Debug for CreateClusterInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateClusterInputBody");
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("tags", &self.tags);
        formatter.field("settings", &self.settings);
        formatter.field("configuration", &self.configuration);
        formatter.field("capacity_providers", &self.capacity_providers);
        formatter.field(
            "default_capacity_provider_strategy",
            &self.default_capacity_provider_strategy,
        );
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateServiceInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster on which to run your service.
    /// If you do not specify a cluster, the default cluster is assumed.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>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.</p>
    pub service_name: &'a std::option::Option<std::string::String>,
    /// <p>The <code>family</code> and <code>revision</code> (<code>family:revision</code>) or
    /// full ARN of the task definition to run in your service. If a <code>revision</code> is
    /// not specified, the latest <code>ACTIVE</code> revision is used.</p>
    /// <p>A task definition must be specified if the service is using either the
    /// <code>ECS</code> or <code>CODE_DEPLOY</code> deployment controllers.</p>
    pub task_definition: &'a std::option::Option<std::string::String>,
    /// <p>A load balancer object representing the load balancers to use with your service. For
    /// more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html">Service Load Balancing</a> in the
    /// <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// <p>If the service is using the rolling update (<code>ECS</code>) 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 make use of
    /// multiple target groups. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Using service-linked roles for Amazon ECS</a> in the
    /// <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// <p>If the service is using the <code>CODE_DEPLOY</code> deployment controller, the
    /// service is required to use either an Application Load Balancer or Network Load Balancer. When creating an AWS CodeDeploy deployment
    /// group, you specify two target groups (referred to as a <code>targetGroupPair</code>).
    /// During a deployment, AWS CodeDeploy determines which task set in your service has the status
    /// <code>PRIMARY</code> and associates one target group with it, and then associates
    /// the other target group with the replacement task set. The load balancer can also have up
    /// to two listeners: a required listener for production traffic and an optional listener
    /// that allows you perform validation tests with Lambda functions before routing production
    /// traffic to it.</p>
    /// <p>After you create a service using the <code>ECS</code> deployment controller, the load
    /// balancer name or target group ARN, container name, and container port specified in the
    /// service definition are immutable. If you are using the <code>CODE_DEPLOY</code>
    /// deployment controller, these values can be changed when updating the service.</p>
    /// <p>For Application Load Balancers and Network Load Balancers, this object must contain the load balancer target group ARN,
    /// the container name (as it appears in a container definition), and the container port to
    /// access from the load balancer. 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 specified here.</p>
    /// <p>For Classic Load Balancers, this object must contain the load balancer name, the container name (as it
    /// appears in a container definition), and the container port to access from the load
    /// balancer. 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 specified here.</p>
    /// <p>Services with tasks that use the <code>awsvpc</code> network mode (for example, those
    /// with the Fargate launch type) only support Application Load Balancers and Network Load Balancers. Classic Load Balancers are
    /// not supported. Also, when you create any target groups for these services, you must
    /// choose <code>ip</code> as the target type, not <code>instance</code>, because tasks that
    /// use the <code>awsvpc</code> network mode are associated with an elastic network
    /// interface, not an Amazon EC2 instance.</p>
    pub load_balancers: &'a std::option::Option<std::vec::Vec<crate::model::LoadBalancer>>,
    /// <p>The details of the service discovery registry to associate with this service. For more
    /// information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html">Service
    /// discovery</a>.</p>
    /// <note>
    /// <p>Each service may be associated with one service registry. Multiple service
    /// registries per service isn't supported.</p>
    /// </note>
    pub service_registries: &'a std::option::Option<std::vec::Vec<crate::model::ServiceRegistry>>,
    /// <p>The number of instantiations of the specified task definition to place and keep
    /// running on your cluster.</p>
    /// <p>This is required if <code>schedulingStrategy</code> is <code>REPLICA</code> or is not
    /// specified. If <code>schedulingStrategy</code> is <code>DAEMON</code> then this is not
    /// required.</p>
    pub desired_count: &'a std::option::Option<i32>,
    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the
    /// request. Up to 32 ASCII characters are allowed.</p>
    pub client_token: &'a std::option::Option<std::string::String>,
    /// <p>The infrastructure on which to run your service. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html">Amazon ECS
    /// launch types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// <p>The <code>FARGATE</code> launch type runs your tasks on AWS Fargate On-Demand
    /// infrastructure.</p>
    /// <note>
    /// <p>Fargate Spot infrastructure is available for use but a capacity provider
    /// strategy must be used. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/fargate-capacity-providers.html">AWS Fargate capacity providers</a> in the
    /// <i>Amazon ECS User Guide for AWS Fargate</i>.</p>
    /// </note>
    /// <p>The <code>EC2</code> launch type runs your tasks on Amazon EC2 instances registered to your
    /// cluster.</p>
    /// <p>The <code>EXTERNAL</code> launch type runs your tasks on your on-premise server or
    /// virtual machine (VM) capacity registered to your cluster.</p>
    /// <p>A service can use either a launch type or a capacity provider strategy. If a
    /// <code>launchType</code> is specified, the <code>capacityProviderStrategy</code>
    /// parameter must be omitted.</p>
    pub launch_type: &'a std::option::Option<crate::model::LaunchType>,
    /// <p>The capacity provider strategy to use for the service.</p>
    /// <p>If a <code>capacityProviderStrategy</code> is specified, the <code>launchType</code>
    /// parameter must be omitted. If no <code>capacityProviderStrategy</code> or
    /// <code>launchType</code> is specified, the
    /// <code>defaultCapacityProviderStrategy</code> for the cluster is used.</p>
    pub capacity_provider_strategy:
        &'a std::option::Option<std::vec::Vec<crate::model::CapacityProviderStrategyItem>>,
    /// <p>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 <code>LATEST</code> platform version is used by default. For more
    /// information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html">AWS Fargate platform
    /// versions</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub platform_version: &'a std::option::Option<std::string::String>,
    /// <p>The name or full Amazon Resource Name (ARN) of the IAM role that allows Amazon ECS to make calls to your
    /// load balancer on your behalf. This parameter is only permitted if you are using a load
    /// balancer with your service and your task definition does not use the <code>awsvpc</code>
    /// network mode. If you specify the <code>role</code> parameter, you must also specify a
    /// load balancer object with the <code>loadBalancers</code> parameter.</p>
    /// <important>
    /// <p>If your account has already created the Amazon ECS service-linked role, that role is
    /// used by default for your service unless you specify a role here. The service-linked
    /// role is required if your task definition uses the <code>awsvpc</code> network mode
    /// or if the service is configured to use service discovery, an external deployment
    /// controller, multiple target groups, or Elastic Inference accelerators in which case
    /// you should not specify a role here. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Using
    /// service-linked roles for Amazon ECS</a> in the
    /// <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// </important>
    /// <p>If your specified role has a path other than <code>/</code>, 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 <code>bar</code> has a path of <code>/foo/</code>
    /// then you would specify <code>/foo/bar</code> as the role name. For more information, see
    /// <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names">Friendly names and paths</a> in the <i>IAM User Guide</i>.</p>
    pub role: &'a std::option::Option<std::string::String>,
    /// <p>Optional deployment parameters that control how many tasks run during the deployment
    /// and the ordering of stopping and starting tasks.</p>
    pub deployment_configuration: &'a std::option::Option<crate::model::DeploymentConfiguration>,
    /// <p>An array of placement constraint objects to use for tasks in your service. You can
    /// specify a maximum of 10 constraints per task (this limit includes constraints in the
    /// task definition and those specified at runtime). </p>
    pub placement_constraints:
        &'a std::option::Option<std::vec::Vec<crate::model::PlacementConstraint>>,
    /// <p>The placement strategy objects to use for tasks in your service. You can specify a
    /// maximum of five strategy rules per service.</p>
    pub placement_strategy: &'a std::option::Option<std::vec::Vec<crate::model::PlacementStrategy>>,
    /// <p>The network configuration for the service. This parameter is required for task
    /// definitions that use the <code>awsvpc</code> network mode to receive their own elastic
    /// network interface, and it is not supported for other network modes. For more
    /// information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task networking</a>
    /// in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub network_configuration: &'a std::option::Option<crate::model::NetworkConfiguration>,
    /// <p>The period of time, in seconds, that the Amazon ECS service scheduler should ignore
    /// unhealthy Elastic Load Balancing target health checks after a task has first started. This is only used
    /// when your service is configured to use a load balancer. If your service has a load
    /// balancer defined and you don't specify a health check grace period value, the default
    /// value of <code>0</code> is used.</p>
    /// <p>If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you
    /// can specify a health check grace period of up to 2,147,483,647 seconds. During that
    /// time, the Amazon ECS service scheduler ignores health check status. This grace period can
    /// prevent the service scheduler from marking tasks as unhealthy and stopping them before
    /// they have time to come up.</p>
    pub health_check_grace_period_seconds: &'a std::option::Option<i32>,
    /// <p>The scheduling strategy to use for the service. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Services</a>.</p>
    /// <p>There are two service scheduler strategies available:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>REPLICA</code>-The replica scheduling strategy places and
    /// maintains the desired number of tasks across your cluster. By default, the
    /// service scheduler spreads tasks across Availability Zones. You can use task
    /// placement strategies and constraints to customize task placement decisions. This
    /// scheduler strategy is required if the service is using the
    /// <code>CODE_DEPLOY</code> or <code>EXTERNAL</code> deployment controller
    /// types.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>DAEMON</code>-The daemon scheduling strategy deploys exactly one
    /// task on each active container instance that meets all of the task placement
    /// constraints that you specify in your cluster. The service scheduler also
    /// evaluates the task placement constraints for running tasks and will stop tasks
    /// that do not meet the placement constraints. When you're using this strategy, you
    /// don't need to specify a desired number of tasks, a task placement strategy, or
    /// use Service Auto Scaling policies.</p>
    /// <note>
    /// <p>Tasks using the Fargate launch type or the
    /// <code>CODE_DEPLOY</code> or <code>EXTERNAL</code> deployment controller
    /// types don't support the <code>DAEMON</code> scheduling strategy.</p>
    /// </note>
    /// </li>
    /// </ul>
    pub scheduling_strategy: &'a std::option::Option<crate::model::SchedulingStrategy>,
    /// <p>The deployment controller to use for the service. If no deployment controller is
    /// specified, the default value of <code>ECS</code> is used.</p>
    pub deployment_controller: &'a std::option::Option<crate::model::DeploymentController>,
    /// <p>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.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For
    /// more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html">Tagging Your Amazon ECS
    /// Resources</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub enable_ecs_managed_tags: &'a bool,
    /// <p>Specifies whether to propagate the tags from the task definition or the service to the
    /// tasks in the service. If no value is specified, the tags are not propagated. Tags can
    /// only be propagated to the tasks within the service during service creation. To add tags
    /// to a task after service creation, use the <a>TagResource</a> API
    /// action.</p>
    pub propagate_tags: &'a std::option::Option<crate::model::PropagateTags>,
    /// <p>Whether or not the execute command functionality is enabled for the service. If
    /// <code>true</code>, this enables execute command functionality on all containers in
    /// the service tasks.</p>
    pub enable_execute_command: &'a bool,
}
impl<'a> std::fmt::Debug for CreateServiceInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateServiceInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("service_name", &self.service_name);
        formatter.field("task_definition", &self.task_definition);
        formatter.field("load_balancers", &self.load_balancers);
        formatter.field("service_registries", &self.service_registries);
        formatter.field("desired_count", &self.desired_count);
        formatter.field("client_token", &self.client_token);
        formatter.field("launch_type", &self.launch_type);
        formatter.field(
            "capacity_provider_strategy",
            &self.capacity_provider_strategy,
        );
        formatter.field("platform_version", &self.platform_version);
        formatter.field("role", &self.role);
        formatter.field("deployment_configuration", &self.deployment_configuration);
        formatter.field("placement_constraints", &self.placement_constraints);
        formatter.field("placement_strategy", &self.placement_strategy);
        formatter.field("network_configuration", &self.network_configuration);
        formatter.field(
            "health_check_grace_period_seconds",
            &self.health_check_grace_period_seconds,
        );
        formatter.field("scheduling_strategy", &self.scheduling_strategy);
        formatter.field("deployment_controller", &self.deployment_controller);
        formatter.field("tags", &self.tags);
        formatter.field("enable_ecs_managed_tags", &self.enable_ecs_managed_tags);
        formatter.field("propagate_tags", &self.propagate_tags);
        formatter.field("enable_execute_command", &self.enable_execute_command);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateTaskSetInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the service to create the task set in.</p>
    pub service: &'a std::option::Option<std::string::String>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the
    /// task set in.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>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 <code>ECS_TASK_SET_EXTERNAL_ID</code> AWS Cloud Map attribute set to the provided
    /// value.</p>
    pub external_id: &'a std::option::Option<std::string::String>,
    /// <p>The task definition for the tasks in the task set to use.</p>
    pub task_definition: &'a std::option::Option<std::string::String>,
    /// <p>An object representing the network configuration for a task set.</p>
    pub network_configuration: &'a std::option::Option<crate::model::NetworkConfiguration>,
    /// <p>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.</p>
    pub load_balancers: &'a std::option::Option<std::vec::Vec<crate::model::LoadBalancer>>,
    /// <p>The details of the service discovery registries to assign to this task set. For more
    /// information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html">Service
    /// Discovery</a>.</p>
    pub service_registries: &'a std::option::Option<std::vec::Vec<crate::model::ServiceRegistry>>,
    /// <p>The launch type that new tasks in the task set will use. For more information, see
    /// <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html">Amazon ECS Launch Types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// <p>If a <code>launchType</code> is specified, the <code>capacityProviderStrategy</code>
    /// parameter must be omitted.</p>
    pub launch_type: &'a std::option::Option<crate::model::LaunchType>,
    /// <p>The capacity provider strategy to use for the task set.</p>
    /// <p>A capacity provider strategy consists of one or more capacity providers along with the
    /// <code>base</code> and <code>weight</code> to assign to them. A capacity provider
    /// must be associated with the cluster to be used in a capacity provider strategy. The
    /// <a>PutClusterCapacityProviders</a> API is used to associate a capacity
    /// provider with a cluster. Only capacity providers with an <code>ACTIVE</code> or
    /// <code>UPDATING</code> status can be used.</p>
    /// <p>If a <code>capacityProviderStrategy</code> is specified, the <code>launchType</code>
    /// parameter must be omitted. If no <code>capacityProviderStrategy</code> or
    /// <code>launchType</code> is specified, the
    /// <code>defaultCapacityProviderStrategy</code> for the cluster is used.</p>
    /// <p>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 <a>CreateCapacityProvider</a> API operation.</p>
    /// <p>To use a AWS Fargate capacity provider, specify either the <code>FARGATE</code> or
    /// <code>FARGATE_SPOT</code> capacity providers. The AWS Fargate capacity providers are
    /// available to all accounts and only need to be associated with a cluster to be
    /// used.</p>
    /// <p>The <a>PutClusterCapacityProviders</a> API operation is used to update the
    /// list of available capacity providers for a cluster after the cluster is created.</p>
    pub capacity_provider_strategy:
        &'a std::option::Option<std::vec::Vec<crate::model::CapacityProviderStrategyItem>>,
    /// <p>The platform version that the tasks in the task set should use. A platform version is
    /// specified only for tasks using the Fargate launch type. If one isn't
    /// specified, the <code>LATEST</code> platform version is used by default.</p>
    pub platform_version: &'a std::option::Option<std::string::String>,
    /// <p>A floating-point percentage of the desired number of tasks to place and keep running
    /// in the task set.</p>
    pub scale: &'a std::option::Option<crate::model::Scale>,
    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the
    /// request. Up to 32 ASCII characters are allowed.</p>
    pub client_token: &'a std::option::Option<std::string::String>,
    /// <p>The metadata that you apply to the task set to help you categorize and organize them.
    /// Each tag consists of a key and an optional value, both of which you define. When a
    /// service is deleted, the tags are deleted as well.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl<'a> std::fmt::Debug for CreateTaskSetInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateTaskSetInputBody");
        formatter.field("service", &self.service);
        formatter.field("cluster", &self.cluster);
        formatter.field("external_id", &self.external_id);
        formatter.field("task_definition", &self.task_definition);
        formatter.field("network_configuration", &self.network_configuration);
        formatter.field("load_balancers", &self.load_balancers);
        formatter.field("service_registries", &self.service_registries);
        formatter.field("launch_type", &self.launch_type);
        formatter.field(
            "capacity_provider_strategy",
            &self.capacity_provider_strategy,
        );
        formatter.field("platform_version", &self.platform_version);
        formatter.field("scale", &self.scale);
        formatter.field("client_token", &self.client_token);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteAccountSettingInputBody<'a> {
    /// <p>The resource name for which to disable the account setting. If
    /// <code>serviceLongArnFormat</code> is specified, the ARN for your Amazon ECS services is
    /// affected. If <code>taskLongArnFormat</code> is specified, the ARN and resource ID for
    /// your Amazon ECS tasks is affected. If <code>containerInstanceLongArnFormat</code> is
    /// specified, the ARN and resource ID for your Amazon ECS container instances is affected. If
    /// <code>awsvpcTrunking</code> is specified, the ENI limit for your Amazon ECS container
    /// instances is affected.</p>
    pub name: &'a std::option::Option<crate::model::SettingName>,
    /// <p>The ARN of the principal, which can be an IAM user, IAM role, or the root user. If you
    /// specify the root user, it disables the account setting for all IAM users, IAM roles, and
    /// the root user of the account unless an IAM user or role explicitly overrides these
    /// settings. If this field is omitted, the setting is changed only for the authenticated
    /// user.</p>
    pub principal_arn: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for DeleteAccountSettingInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteAccountSettingInputBody");
        formatter.field("name", &self.name);
        formatter.field("principal_arn", &self.principal_arn);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteAttributesInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The attributes to delete from your resource. You can specify up to 10 attributes per
    /// request. For custom attributes, specify the attribute name and target ID, but do not
    /// specify the value. If you specify the target ID using the short form, you must also
    /// specify the target type.</p>
    pub attributes: &'a std::option::Option<std::vec::Vec<crate::model::Attribute>>,
}
impl<'a> std::fmt::Debug for DeleteAttributesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteAttributesInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("attributes", &self.attributes);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteCapacityProviderInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the capacity provider to delete.</p>
    pub capacity_provider: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for DeleteCapacityProviderInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteCapacityProviderInputBody");
        formatter.field("capacity_provider", &self.capacity_provider);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteClusterInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster to delete.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for DeleteClusterInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteClusterInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteServiceInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The name of the service to delete.</p>
    pub service: &'a std::option::Option<std::string::String>,
    /// <p>If <code>true</code>, allows you to delete a service even if it has not been scaled
    /// down to zero tasks. It is only necessary to use this if the service is using the
    /// <code>REPLICA</code> scheduling strategy.</p>
    pub force: &'a std::option::Option<bool>,
}
impl<'a> std::fmt::Debug for DeleteServiceInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteServiceInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("service", &self.service);
        formatter.field("force", &self.force);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteTaskSetInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service that the task
    /// set exists in to delete.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the service that hosts the task set to
    /// delete.</p>
    pub service: &'a std::option::Option<std::string::String>,
    /// <p>The task set ID or full Amazon Resource Name (ARN) of the task set to delete.</p>
    pub task_set: &'a std::option::Option<std::string::String>,
    /// <p>If <code>true</code>, this allows you to delete a task set even if it hasn't been
    /// scaled down to zero.</p>
    pub force: &'a std::option::Option<bool>,
}
impl<'a> std::fmt::Debug for DeleteTaskSetInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteTaskSetInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("service", &self.service);
        formatter.field("task_set", &self.task_set);
        formatter.field("force", &self.force);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterContainerInstanceInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The container instance ID or full ARN of the container instance to deregister.
    /// The ARN contains the <code>arn:aws:ecs</code> namespace, followed by the Region of the container instance, the AWS account ID of the container instance owner, the <code>container-instance</code> namespace, and then the container instance ID. For example, <code>arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID</code>.</p>
    pub container_instance: &'a std::option::Option<std::string::String>,
    /// <p>Forces the deregistration of the container instance. If you have tasks running on the
    /// container instance when you deregister it with the <code>force</code> option, these
    /// tasks remain running until you terminate the instance or the tasks stop through some
    /// other means, but they are orphaned (no longer monitored or accounted for by Amazon ECS). If
    /// an orphaned task on your container instance is part of an Amazon ECS service, then the
    /// service scheduler starts another copy of that task, on a different container instance if
    /// possible. </p>
    /// <p>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.</p>
    pub force: &'a std::option::Option<bool>,
}
impl<'a> std::fmt::Debug for DeregisterContainerInstanceInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterContainerInstanceInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("container_instance", &self.container_instance);
        formatter.field("force", &self.force);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterTaskDefinitionInputBody<'a> {
    /// <p>The <code>family</code> and <code>revision</code> (<code>family:revision</code>) or
    /// full Amazon Resource Name (ARN) of the task definition to deregister. You must specify a
    /// <code>revision</code>.</p>
    pub task_definition: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for DeregisterTaskDefinitionInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterTaskDefinitionInputBody");
        formatter.field("task_definition", &self.task_definition);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeCapacityProvidersInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of one or more capacity providers. Up to
    /// <code>100</code> capacity providers can be described in an action.</p>
    pub capacity_providers: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Specifies whether or not you want to see the resource tags for the capacity provider.
    /// If <code>TAGS</code> is specified, the tags are included in the response. If this field
    /// is omitted, tags are not included in the response.</p>
    pub include: &'a std::option::Option<std::vec::Vec<crate::model::CapacityProviderField>>,
    /// <p>The maximum number of account setting results returned by
    /// <code>DescribeCapacityProviders</code> in paginated output. When this parameter is
    /// used, <code>DescribeCapacityProviders</code> only returns <code>maxResults</code>
    /// results in a single page along with a <code>nextToken</code> response element. The
    /// remaining results of the initial request can be seen by sending another
    /// <code>DescribeCapacityProviders</code> request with the returned
    /// <code>nextToken</code> value. This value can be between
    /// 1 and 10. If this
    /// parameter is not used, then <code>DescribeCapacityProviders</code> returns up to
    /// 10 results and a <code>nextToken</code> value
    /// if applicable.</p>
    pub max_results: &'a std::option::Option<i32>,
    /// <p>The <code>nextToken</code> value returned from a previous paginated
    /// <code>DescribeCapacityProviders</code> request where <code>maxResults</code> was
    /// used and the results exceeded the value of that parameter. Pagination continues from the
    /// end of the previous results that returned the <code>nextToken</code> value.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for DescribeCapacityProvidersInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeCapacityProvidersInputBody");
        formatter.field("capacity_providers", &self.capacity_providers);
        formatter.field("include", &self.include);
        formatter.field("max_results", &self.max_results);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeClustersInputBody<'a> {
    /// <p>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.</p>
    pub clusters: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Whether to include additional information about the clusters in the response. If this
    /// field is omitted, this information isn't included.</p>
    /// <p>If <code>ATTACHMENTS</code> is specified, the attachments for the container instances
    /// or tasks within the cluster are included.</p>
    /// <p>If <code>SETTINGS</code> is specified, the settings for the cluster are
    /// included.</p>
    /// <p>If <code>STATISTICS</code> is specified, the task and service count is included,
    /// separated by launch type.</p>
    /// <p>If <code>TAGS</code> is specified, the metadata tags associated with the cluster are
    /// included.</p>
    pub include: &'a std::option::Option<std::vec::Vec<crate::model::ClusterField>>,
}
impl<'a> std::fmt::Debug for DescribeClustersInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeClustersInputBody");
        formatter.field("clusters", &self.clusters);
        formatter.field("include", &self.include);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeContainerInstancesInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>A list of up to 100 container instance IDs or full Amazon Resource Name (ARN) entries.</p>
    pub container_instances: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Specifies whether you want to see the resource tags for the container instance. If
    /// <code>TAGS</code> is specified, the tags are included in the response. If this field
    /// is omitted, tags are not included in the response.</p>
    pub include: &'a std::option::Option<std::vec::Vec<crate::model::ContainerInstanceField>>,
}
impl<'a> std::fmt::Debug for DescribeContainerInstancesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeContainerInstancesInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("container_instances", &self.container_instances);
        formatter.field("include", &self.include);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeServicesInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>A list of services to describe. You may specify up to 10 services to describe in a
    /// single operation.</p>
    pub services: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Specifies whether you want to see the resource tags for the service. If
    /// <code>TAGS</code> is specified, the tags are included in the response. If this field
    /// is omitted, tags are not included in the response.</p>
    pub include: &'a std::option::Option<std::vec::Vec<crate::model::ServiceField>>,
}
impl<'a> std::fmt::Debug for DescribeServicesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeServicesInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("services", &self.services);
        formatter.field("include", &self.include);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeTaskDefinitionInputBody<'a> {
    /// <p>The <code>family</code> for the latest <code>ACTIVE</code> revision,
    /// <code>family</code> and <code>revision</code> (<code>family:revision</code>) for a
    /// specific revision in the family, or full Amazon Resource Name (ARN) of the task definition to
    /// describe.</p>
    pub task_definition: &'a std::option::Option<std::string::String>,
    /// <p>Specifies whether to see the resource tags for the task definition. If
    /// <code>TAGS</code> is specified, the tags are included in the response. If this field
    /// is omitted, tags are not included in the response.</p>
    pub include: &'a std::option::Option<std::vec::Vec<crate::model::TaskDefinitionField>>,
}
impl<'a> std::fmt::Debug for DescribeTaskDefinitionInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeTaskDefinitionInputBody");
        formatter.field("task_definition", &self.task_definition);
        formatter.field("include", &self.include);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeTasksInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>A list of up to 100 task IDs or full ARN entries.</p>
    pub tasks: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Specifies whether you want to see the resource tags for the task. If <code>TAGS</code>
    /// is specified, the tags are included in the response. If this field is omitted, tags are
    /// not included in the response.</p>
    pub include: &'a std::option::Option<std::vec::Vec<crate::model::TaskField>>,
}
impl<'a> std::fmt::Debug for DescribeTasksInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeTasksInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("tasks", &self.tasks);
        formatter.field("include", &self.include);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeTaskSetsInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service that the task
    /// sets exist in.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the service that the task sets exist in.</p>
    pub service: &'a std::option::Option<std::string::String>,
    /// <p>The ID or full Amazon Resource Name (ARN) of task sets to
    /// describe.</p>
    pub task_sets: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Specifies whether to see the resource tags for the task set. If <code>TAGS</code> is
    /// specified, the tags are included in the response. If this field is omitted, tags are not
    /// included in the response.</p>
    pub include: &'a std::option::Option<std::vec::Vec<crate::model::TaskSetField>>,
}
impl<'a> std::fmt::Debug for DescribeTaskSetsInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeTaskSetsInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("service", &self.service);
        formatter.field("task_sets", &self.task_sets);
        formatter.field("include", &self.include);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DiscoverPollEndpointInputBody<'a> {
    /// <p>The container instance ID or full ARN of the container instance.
    /// The ARN contains the <code>arn:aws:ecs</code> namespace, followed by the Region of the container instance, the AWS account ID of the container instance owner, the <code>container-instance</code> namespace, and then the container instance ID. For example, <code>arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID</code>.</p>
    pub container_instance: &'a std::option::Option<std::string::String>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster to which the container instance
    /// belongs.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for DiscoverPollEndpointInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DiscoverPollEndpointInputBody");
        formatter.field("container_instance", &self.container_instance);
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ExecuteCommandInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The name of the container to execute the command on. A container name only needs to be
    /// specified for tasks containing multiple containers.</p>
    pub container: &'a std::option::Option<std::string::String>,
    /// <p>The command to run on the container.</p>
    pub command: &'a std::option::Option<std::string::String>,
    /// <p>Use this flag to run your command in interactive mode.</p>
    pub interactive: &'a bool,
    /// <p>The Amazon Resource Name (ARN) or ID of the task the container is part of.</p>
    pub task: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for ExecuteCommandInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ExecuteCommandInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("container", &self.container);
        formatter.field("command", &self.command);
        formatter.field("interactive", &self.interactive);
        formatter.field("task", &self.task);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListAccountSettingsInputBody<'a> {
    /// <p>The name of the account setting you want to list the settings for.</p>
    pub name: &'a std::option::Option<crate::model::SettingName>,
    /// <p>The value of the account settings with which to filter results. You must also specify
    /// an account setting name to use this parameter.</p>
    pub value: &'a std::option::Option<std::string::String>,
    /// <p>The ARN of the principal, which can be an IAM user, IAM role, or the root user. If
    /// this field is omitted, the account settings are listed only for the authenticated
    /// user.</p>
    /// <note>
    /// <p>Federated users assume the account setting of the root user and can't have
    /// explicit account settings set for them.</p>
    /// </note>
    pub principal_arn: &'a std::option::Option<std::string::String>,
    /// <p>Specifies whether to return the effective settings. If <code>true</code>, the account
    /// settings for the root user or the default setting for the <code>principalArn</code> are
    /// returned. If <code>false</code>, the account settings for the <code>principalArn</code>
    /// are returned if they are set. Otherwise, no account settings are returned.</p>
    pub effective_settings: &'a bool,
    /// <p>The <code>nextToken</code> value returned from a <code>ListAccountSettings</code>
    /// request indicating that more results are available to fulfill the request and further
    /// calls will be needed. If <code>maxResults</code> was provided, it is possible the number
    /// of results to be fewer than <code>maxResults</code>.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
    /// <p>The maximum number of account setting results returned by
    /// <code>ListAccountSettings</code> in paginated output. When this parameter is used,
    /// <code>ListAccountSettings</code> only returns <code>maxResults</code> results in a
    /// single page along with a <code>nextToken</code> response element. The remaining results
    /// of the initial request can be seen by sending another <code>ListAccountSettings</code>
    /// request with the returned <code>nextToken</code> value. This value can be between
    /// 1 and 10. If this
    /// parameter is not used, then <code>ListAccountSettings</code> returns up to
    /// 10 results and a <code>nextToken</code> value
    /// if applicable.</p>
    pub max_results: &'a i32,
}
impl<'a> std::fmt::Debug for ListAccountSettingsInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListAccountSettingsInputBody");
        formatter.field("name", &self.name);
        formatter.field("value", &self.value);
        formatter.field("principal_arn", &self.principal_arn);
        formatter.field("effective_settings", &self.effective_settings);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListAttributesInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The type of the target with which to list attributes.</p>
    pub target_type: &'a std::option::Option<crate::model::TargetType>,
    /// <p>The name of the attribute with which to filter the results. </p>
    pub attribute_name: &'a std::option::Option<std::string::String>,
    /// <p>The value of the attribute with which to filter results. You must also specify an
    /// attribute name to use this parameter.</p>
    pub attribute_value: &'a std::option::Option<std::string::String>,
    /// <p>The <code>nextToken</code> value returned from a <code>ListAttributes</code> request
    /// indicating that more results are available to fulfill the request and further calls will
    /// be needed. If <code>maxResults</code> was provided, it is possible the number of results
    /// to be fewer than <code>maxResults</code>.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
    /// <p>The maximum number of cluster results returned by <code>ListAttributes</code> in
    /// paginated output. When this parameter is used, <code>ListAttributes</code> only returns
    /// <code>maxResults</code> results in a single page along with a <code>nextToken</code>
    /// response element. The remaining results of the initial request can be seen by sending
    /// another <code>ListAttributes</code> request with the returned <code>nextToken</code>
    /// value. This value can be between 1 and 100. If this
    /// parameter is not used, then <code>ListAttributes</code> returns up to
    /// 100 results and a <code>nextToken</code> value if applicable.</p>
    pub max_results: &'a std::option::Option<i32>,
}
impl<'a> std::fmt::Debug for ListAttributesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListAttributesInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("target_type", &self.target_type);
        formatter.field("attribute_name", &self.attribute_name);
        formatter.field("attribute_value", &self.attribute_value);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListClustersInputBody<'a> {
    /// <p>The <code>nextToken</code> value returned from a <code>ListClusters</code> request
    /// indicating that more results are available to fulfill the request and further calls will
    /// be needed. If <code>maxResults</code> was provided, it is possible the number of results
    /// to be fewer than <code>maxResults</code>.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
    /// <p>The maximum number of cluster results returned by <code>ListClusters</code> in
    /// paginated output. When this parameter is used, <code>ListClusters</code> only returns
    /// <code>maxResults</code> results in a single page along with a <code>nextToken</code>
    /// response element. The remaining results of the initial request can be seen by sending
    /// another <code>ListClusters</code> request with the returned <code>nextToken</code>
    /// value. This value can be between 1 and 100. If this
    /// parameter is not used, then <code>ListClusters</code> returns up to
    /// 100 results and a <code>nextToken</code> value if applicable.</p>
    pub max_results: &'a std::option::Option<i32>,
}
impl<'a> std::fmt::Debug for ListClustersInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListClustersInputBody");
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListContainerInstancesInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>You can filter the results of a <code>ListContainerInstances</code> operation with
    /// cluster query language statements. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html">Cluster Query Language</a> in the
    /// <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub filter: &'a std::option::Option<std::string::String>,
    /// <p>The <code>nextToken</code> value returned from a <code>ListContainerInstances</code>
    /// request indicating that more results are available to fulfill the request and further
    /// calls will be needed. If <code>maxResults</code> was provided, it is possible the number
    /// of results to be fewer than <code>maxResults</code>.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
    /// <p>The maximum number of container instance results returned by
    /// <code>ListContainerInstances</code> in paginated output. When this parameter is
    /// used, <code>ListContainerInstances</code> only returns <code>maxResults</code> results
    /// in a single page along with a <code>nextToken</code> response element. The remaining
    /// results of the initial request can be seen by sending another
    /// <code>ListContainerInstances</code> request with the returned <code>nextToken</code>
    /// value. This value can be between 1 and 100. If this
    /// parameter is not used, then <code>ListContainerInstances</code> returns up to
    /// 100 results and a <code>nextToken</code> value if applicable.</p>
    pub max_results: &'a std::option::Option<i32>,
    /// <p>Filters the container instances by status. For example, if you specify the
    /// <code>DRAINING</code> status, the results include only container instances that have
    /// been set to <code>DRAINING</code> using <a>UpdateContainerInstancesState</a>.
    /// If you do not specify this parameter, the default is to include container instances set
    /// to all states other than <code>INACTIVE</code>.</p>
    pub status: &'a std::option::Option<crate::model::ContainerInstanceStatus>,
}
impl<'a> std::fmt::Debug for ListContainerInstancesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListContainerInstancesInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("filter", &self.filter);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.field("status", &self.status);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListServicesInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster to use when filtering the
    /// <code>ListServices</code> results. If you do not specify a cluster, the default cluster is assumed.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The <code>nextToken</code> value returned from a <code>ListServices</code> request
    /// indicating that more results are available to fulfill the request and further calls will
    /// be needed. If <code>maxResults</code> was provided, it is possible the number of results
    /// to be fewer than <code>maxResults</code>.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
    /// <p>The maximum number of service results returned by <code>ListServices</code> in
    /// paginated output. When this parameter is used, <code>ListServices</code> only returns
    /// <code>maxResults</code> results in a single page along with a <code>nextToken</code>
    /// response element. The remaining results of the initial request can be seen by sending
    /// another <code>ListServices</code> request with the returned <code>nextToken</code>
    /// value. This value can be between 1 and 100. If
    /// this parameter is not used, then <code>ListServices</code> returns up to
    /// 10 results and a <code>nextToken</code> value if
    /// applicable.</p>
    pub max_results: &'a std::option::Option<i32>,
    /// <p>The launch type to use when filtering the <code>ListServices</code> results.</p>
    pub launch_type: &'a std::option::Option<crate::model::LaunchType>,
    /// <p>The scheduling strategy to use when filtering the <code>ListServices</code>
    /// results.</p>
    pub scheduling_strategy: &'a std::option::Option<crate::model::SchedulingStrategy>,
}
impl<'a> std::fmt::Debug for ListServicesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListServicesInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.field("launch_type", &self.launch_type);
        formatter.field("scheduling_strategy", &self.scheduling_strategy);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceInputBody<'a> {
    /// <p>The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. Currently, the
    /// supported resources are Amazon ECS tasks, services, task definitions, clusters, and container
    /// instances.</p>
    pub resource_arn: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for ListTagsForResourceInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsForResourceInputBody");
        formatter.field("resource_arn", &self.resource_arn);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTaskDefinitionFamiliesInputBody<'a> {
    /// <p>The <code>familyPrefix</code> is a string that is used to filter the results of
    /// <code>ListTaskDefinitionFamilies</code>. If you specify a <code>familyPrefix</code>,
    /// only task definition family names that begin with the <code>familyPrefix</code> string
    /// are returned.</p>
    pub family_prefix: &'a std::option::Option<std::string::String>,
    /// <p>The task definition family status with which to filter the
    /// <code>ListTaskDefinitionFamilies</code> results. By default, both
    /// <code>ACTIVE</code> and <code>INACTIVE</code> task definition families are listed.
    /// If this parameter is set to <code>ACTIVE</code>, only task definition families that have
    /// an <code>ACTIVE</code> task definition revision are returned. If this parameter is set
    /// to <code>INACTIVE</code>, only task definition families that do not have any
    /// <code>ACTIVE</code> task definition revisions are returned. If you paginate the
    /// resulting output, be sure to keep the <code>status</code> value constant in each
    /// subsequent request.</p>
    pub status: &'a std::option::Option<crate::model::TaskDefinitionFamilyStatus>,
    /// <p>The <code>nextToken</code> value returned from a
    /// <code>ListTaskDefinitionFamilies</code> request indicating that more results are
    /// available to fulfill the request and further calls will be needed. If
    /// <code>maxResults</code> was provided, it is possible the number of results to be
    /// fewer than <code>maxResults</code>.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
    /// <p>The maximum number of task definition family results returned by
    /// <code>ListTaskDefinitionFamilies</code> in paginated output. When this parameter is
    /// used, <code>ListTaskDefinitions</code> only returns <code>maxResults</code> results in a
    /// single page along with a <code>nextToken</code> response element. The remaining results
    /// of the initial request can be seen by sending another
    /// <code>ListTaskDefinitionFamilies</code> request with the returned
    /// <code>nextToken</code> value. This value can be between 1 and
    /// 100. If this parameter is not used, then
    /// <code>ListTaskDefinitionFamilies</code> returns up to 100 results
    /// and a <code>nextToken</code> value if applicable.</p>
    pub max_results: &'a std::option::Option<i32>,
}
impl<'a> std::fmt::Debug for ListTaskDefinitionFamiliesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTaskDefinitionFamiliesInputBody");
        formatter.field("family_prefix", &self.family_prefix);
        formatter.field("status", &self.status);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTaskDefinitionsInputBody<'a> {
    /// <p>The full family name with which to filter the <code>ListTaskDefinitions</code>
    /// results. Specifying a <code>familyPrefix</code> limits the listed task definitions to
    /// task definition revisions that belong to that family.</p>
    pub family_prefix: &'a std::option::Option<std::string::String>,
    /// <p>The task definition status with which to filter the <code>ListTaskDefinitions</code>
    /// results. By default, only <code>ACTIVE</code> task definitions are listed. By setting
    /// this parameter to <code>INACTIVE</code>, you can view task definitions that are
    /// <code>INACTIVE</code> as long as an active task or service still references them. If
    /// you paginate the resulting output, be sure to keep the <code>status</code> value
    /// constant in each subsequent request.</p>
    pub status: &'a std::option::Option<crate::model::TaskDefinitionStatus>,
    /// <p>The order in which to sort the results. Valid values are <code>ASC</code> and
    /// <code>DESC</code>. By default (<code>ASC</code>), 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
    /// <code>DESC</code> reverses the sort order on family name and revision so that the
    /// newest task definitions in a family are listed first.</p>
    pub sort: &'a std::option::Option<crate::model::SortOrder>,
    /// <p>The <code>nextToken</code> value returned from a <code>ListTaskDefinitions</code>
    /// request indicating that more results are available to fulfill the request and further
    /// calls will be needed. If <code>maxResults</code> was provided, it is possible the number
    /// of results to be fewer than <code>maxResults</code>.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
    /// <p>The maximum number of task definition results returned by
    /// <code>ListTaskDefinitions</code> in paginated output. When this parameter is used,
    /// <code>ListTaskDefinitions</code> only returns <code>maxResults</code> results in a
    /// single page along with a <code>nextToken</code> response element. The remaining results
    /// of the initial request can be seen by sending another <code>ListTaskDefinitions</code>
    /// request with the returned <code>nextToken</code> value. This value can be between
    /// 1 and 100. If this parameter is not used, then
    /// <code>ListTaskDefinitions</code> returns up to 100 results and a
    /// <code>nextToken</code> value if applicable.</p>
    pub max_results: &'a std::option::Option<i32>,
}
impl<'a> std::fmt::Debug for ListTaskDefinitionsInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTaskDefinitionsInputBody");
        formatter.field("family_prefix", &self.family_prefix);
        formatter.field("status", &self.status);
        formatter.field("sort", &self.sort);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTasksInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster to use when filtering the
    /// <code>ListTasks</code> results. If you do not specify a cluster, the default cluster is assumed.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The container instance ID or full ARN of the container instance to use when
    /// filtering the <code>ListTasks</code> results. Specifying a
    /// <code>containerInstance</code> limits the results to tasks that belong to that
    /// container instance.</p>
    pub container_instance: &'a std::option::Option<std::string::String>,
    /// <p>The name of the task definition family to use when filtering the
    /// <code>ListTasks</code> results. Specifying a <code>family</code> limits the results
    /// to tasks that belong to that family.</p>
    pub family: &'a std::option::Option<std::string::String>,
    /// <p>The <code>nextToken</code> value returned from a <code>ListTasks</code> request
    /// indicating that more results are available to fulfill the request and further calls will
    /// be needed. If <code>maxResults</code> was provided, it is possible the number of results
    /// to be fewer than <code>maxResults</code>.</p>
    /// <note>
    /// <p>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.</p>
    /// </note>
    pub next_token: &'a std::option::Option<std::string::String>,
    /// <p>The maximum number of task results returned by <code>ListTasks</code> in paginated
    /// output. When this parameter is used, <code>ListTasks</code> only returns
    /// <code>maxResults</code> results in a single page along with a <code>nextToken</code>
    /// response element. The remaining results of the initial request can be seen by sending
    /// another <code>ListTasks</code> request with the returned <code>nextToken</code> value.
    /// This value can be between 1 and 100. If this parameter is
    /// not used, then <code>ListTasks</code> returns up to 100 results and a
    /// <code>nextToken</code> value if applicable.</p>
    pub max_results: &'a std::option::Option<i32>,
    /// <p>The <code>startedBy</code> value with which to filter the task results. Specifying a
    /// <code>startedBy</code> value limits the results to tasks that were started with that
    /// value.</p>
    pub started_by: &'a std::option::Option<std::string::String>,
    /// <p>The name of the service to use when filtering the <code>ListTasks</code> results.
    /// Specifying a <code>serviceName</code> limits the results to tasks that belong to that
    /// service.</p>
    pub service_name: &'a std::option::Option<std::string::String>,
    /// <p>The task desired status to use when filtering the <code>ListTasks</code> results.
    /// Specifying a <code>desiredStatus</code> of <code>STOPPED</code> limits the results to
    /// tasks that Amazon ECS has set the desired status to <code>STOPPED</code>. This can be useful
    /// for debugging tasks that are not starting properly or have died or finished. The default
    /// status filter is <code>RUNNING</code>, which shows tasks that Amazon ECS has set the desired
    /// status to <code>RUNNING</code>.</p>
    /// <note>
    /// <p>Although you can filter results based on a desired status of <code>PENDING</code>,
    /// this does not return any results. Amazon ECS never sets the desired status of a task to
    /// that value (only a task's <code>lastStatus</code> may have a value of
    /// <code>PENDING</code>).</p>
    /// </note>
    pub desired_status: &'a std::option::Option<crate::model::DesiredStatus>,
    /// <p>The launch type to use when filtering the <code>ListTasks</code> results.</p>
    pub launch_type: &'a std::option::Option<crate::model::LaunchType>,
}
impl<'a> std::fmt::Debug for ListTasksInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTasksInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("container_instance", &self.container_instance);
        formatter.field("family", &self.family);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.field("started_by", &self.started_by);
        formatter.field("service_name", &self.service_name);
        formatter.field("desired_status", &self.desired_status);
        formatter.field("launch_type", &self.launch_type);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAccountSettingInputBody<'a> {
    /// <p>The Amazon ECS resource name for which to modify the account setting. If
    /// <code>serviceLongArnFormat</code> is specified, the ARN for your Amazon ECS services is
    /// affected. If <code>taskLongArnFormat</code> is specified, the ARN and resource ID for
    /// your Amazon ECS tasks is affected. If <code>containerInstanceLongArnFormat</code> is
    /// specified, the ARN and resource ID for your Amazon ECS container instances is affected. If
    /// <code>awsvpcTrunking</code> is specified, the elastic network interface (ENI) limit
    /// for your Amazon ECS container instances is affected. If <code>containerInsights</code> is
    /// specified, the default setting for CloudWatch Container Insights for your clusters is
    /// affected.</p>
    pub name: &'a std::option::Option<crate::model::SettingName>,
    /// <p>The account setting value for the specified principal ARN. Accepted values are
    /// <code>enabled</code> and <code>disabled</code>.</p>
    pub value: &'a std::option::Option<std::string::String>,
    /// <p>The ARN of the principal, which can be an IAM user, IAM role, or the root user. If you
    /// specify the root user, it modifies the account setting for all IAM users, IAM roles, and
    /// the root user of the account unless an IAM user or role explicitly overrides these
    /// settings. If this field is omitted, the setting is changed only for the authenticated
    /// user.</p>
    /// <note>
    /// <p>Federated users assume the account setting of the root user and can't have
    /// explicit account settings set for them.</p>
    /// </note>
    pub principal_arn: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for PutAccountSettingInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAccountSettingInputBody");
        formatter.field("name", &self.name);
        formatter.field("value", &self.value);
        formatter.field("principal_arn", &self.principal_arn);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAccountSettingDefaultInputBody<'a> {
    /// <p>The resource name for which to modify the account setting. If
    /// <code>serviceLongArnFormat</code> is specified, the ARN for your Amazon ECS services is
    /// affected. If <code>taskLongArnFormat</code> is specified, the ARN and resource ID for
    /// your Amazon ECS tasks is affected. If <code>containerInstanceLongArnFormat</code> is
    /// specified, the ARN and resource ID for your Amazon ECS container instances is affected. If
    /// <code>awsvpcTrunking</code> is specified, the ENI limit for your Amazon ECS container
    /// instances is affected. If <code>containerInsights</code> is specified, the default
    /// setting for CloudWatch Container Insights for your clusters is affected.</p>
    pub name: &'a std::option::Option<crate::model::SettingName>,
    /// <p>The account setting value for the specified principal ARN. Accepted values are
    /// <code>enabled</code> and <code>disabled</code>.</p>
    pub value: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for PutAccountSettingDefaultInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAccountSettingDefaultInputBody");
        formatter.field("name", &self.name);
        formatter.field("value", &self.value);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAttributesInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The attributes to apply to your resource. You can specify up to 10 custom attributes
    /// per resource. You can specify up to 10 attributes in a single call.</p>
    pub attributes: &'a std::option::Option<std::vec::Vec<crate::model::Attribute>>,
}
impl<'a> std::fmt::Debug for PutAttributesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAttributesInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("attributes", &self.attributes);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutClusterCapacityProvidersInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster to modify the capacity provider
    /// settings for. If you do not specify a cluster, the default cluster is assumed.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The name of one or more capacity providers to associate with the cluster.</p>
    /// <p>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 <a>CreateCapacityProvider</a> API operation.</p>
    /// <p>To use a AWS Fargate capacity provider, specify either the <code>FARGATE</code> or
    /// <code>FARGATE_SPOT</code> capacity providers. The AWS Fargate capacity providers are
    /// available to all accounts and only need to be associated with a cluster to be
    /// used.</p>
    pub capacity_providers: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The capacity provider strategy to use by default for the cluster.</p>
    /// <p>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.</p>
    /// <p>A capacity provider strategy consists of one or more capacity providers along with the
    /// <code>base</code> and <code>weight</code> to assign to them. A capacity provider
    /// must be associated with the cluster to be used in a capacity provider strategy. The
    /// <a>PutClusterCapacityProviders</a> API is used to associate a capacity
    /// provider with a cluster. Only capacity providers with an <code>ACTIVE</code> or
    /// <code>UPDATING</code> status can be used.</p>
    /// <p>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 <a>CreateCapacityProvider</a> API operation.</p>
    /// <p>To use a AWS Fargate capacity provider, specify either the <code>FARGATE</code> or
    /// <code>FARGATE_SPOT</code> capacity providers. The AWS Fargate capacity providers are
    /// available to all accounts and only need to be associated with a cluster to be
    /// used.</p>
    pub default_capacity_provider_strategy:
        &'a std::option::Option<std::vec::Vec<crate::model::CapacityProviderStrategyItem>>,
}
impl<'a> std::fmt::Debug for PutClusterCapacityProvidersInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutClusterCapacityProvidersInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("capacity_providers", &self.capacity_providers);
        formatter.field(
            "default_capacity_provider_strategy",
            &self.default_capacity_provider_strategy,
        );
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterContainerInstanceInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster with which to register your container
    /// instance. If you do not specify a cluster, the default cluster is assumed.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The instance identity document for the EC2 instance to register. This document can be
    /// found by running the following command from the instance: <code>curl
    /// http://169.254.169.254/latest/dynamic/instance-identity/document/</code>
    /// </p>
    pub instance_identity_document: &'a std::option::Option<std::string::String>,
    /// <p>The instance identity document signature for the EC2 instance to register. This
    /// signature can be found by running the following command from the instance: <code>curl
    /// http://169.254.169.254/latest/dynamic/instance-identity/signature/</code>
    /// </p>
    pub instance_identity_document_signature: &'a std::option::Option<std::string::String>,
    /// <p>The resources available on the instance.</p>
    pub total_resources: &'a std::option::Option<std::vec::Vec<crate::model::Resource>>,
    /// <p>The version information for the Amazon ECS container agent and Docker daemon running on the
    /// container instance.</p>
    pub version_info: &'a std::option::Option<crate::model::VersionInfo>,
    /// <p>The ARN of the container instance (if it was previously registered).</p>
    pub container_instance_arn: &'a std::option::Option<std::string::String>,
    /// <p>The container instance attributes that this container instance supports.</p>
    pub attributes: &'a std::option::Option<std::vec::Vec<crate::model::Attribute>>,
    /// <p>The devices that are available on the container instance. The only supported device
    /// type is a GPU.</p>
    pub platform_devices: &'a std::option::Option<std::vec::Vec<crate::model::PlatformDevice>>,
    /// <p>The metadata that you apply to the container instance to help you categorize and
    /// organize them. Each tag consists of a key and an optional value, both of which you
    /// define.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl<'a> std::fmt::Debug for RegisterContainerInstanceInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterContainerInstanceInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field(
            "instance_identity_document",
            &self.instance_identity_document,
        );
        formatter.field(
            "instance_identity_document_signature",
            &self.instance_identity_document_signature,
        );
        formatter.field("total_resources", &self.total_resources);
        formatter.field("version_info", &self.version_info);
        formatter.field("container_instance_arn", &self.container_instance_arn);
        formatter.field("attributes", &self.attributes);
        formatter.field("platform_devices", &self.platform_devices);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterTaskDefinitionInputBody<'a> {
    /// <p>You must specify a <code>family</code> for a task definition, which allows you to
    /// track multiple versions of the same task definition. The <code>family</code> is used as
    /// a name for your task definition. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed.</p>
    pub family: &'a std::option::Option<std::string::String>,
    /// <p>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 <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM Roles for
    /// Tasks</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub task_role_arn: &'a std::option::Option<std::string::String>,
    /// <p>The Amazon Resource Name (ARN) of the task execution role that grants the Amazon ECS container agent
    /// permission to make AWS API calls on your behalf. The task execution IAM role is required
    /// depending on the requirements of your task. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon ECS task
    /// execution IAM role</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub execution_role_arn: &'a std::option::Option<std::string::String>,
    /// <p>The Docker networking mode to use for the containers in the task. The valid values are
    /// <code>none</code>, <code>bridge</code>, <code>awsvpc</code>, and <code>host</code>.
    /// If no network mode is specified, the default is <code>bridge</code>.</p>
    /// <p>For Amazon ECS tasks on Fargate, the <code>awsvpc</code> network mode is required.
    /// For Amazon ECS tasks on Amazon EC2 instances, any network mode can be used. If the network
    /// mode is set to <code>none</code>, you cannot specify port mappings in your container
    /// definitions, and the tasks containers do not have external connectivity. The
    /// <code>host</code> and <code>awsvpc</code> 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 <code>bridge</code> mode.</p>
    /// <p>With the <code>host</code> and <code>awsvpc</code> network modes, exposed container
    /// ports are mapped directly to the corresponding host port (for the <code>host</code>
    /// network mode) or the attached elastic network interface port (for the
    /// <code>awsvpc</code> network mode), so you cannot take advantage of dynamic host port
    /// mappings. </p>
    /// <important>
    /// <p>When using the <code>host</code> network mode, you should not run
    /// containers using the root user (UID 0). It is considered best practice
    /// to use a non-root user.</p>
    /// </important>
    /// <p>If the network mode is <code>awsvpc</code>, the task is allocated an elastic network
    /// interface, and you must specify a <a>NetworkConfiguration</a> value when you create
    /// a service or run a task with the task definition. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task Networking</a> in the
    /// <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// <note>
    /// <p>Currently, only Amazon ECS-optimized AMIs, other Amazon Linux variants with the
    /// <code>ecs-init</code> package, or AWS Fargate infrastructure support the
    /// <code>awsvpc</code> network mode. </p>
    /// </note>
    /// <p>If the network mode is <code>host</code>, you cannot run multiple instantiations of the
    /// same task on a single container instance when port mappings are used.</p>
    /// <p>Docker for Windows uses different network modes than Docker for Linux. When you
    /// register a task definition with Windows containers, you must not specify a network mode.
    /// If you use the console to register a task definition with Windows containers, you must
    /// choose the <code><default></code> network mode object. </p>
    /// <p>For more information, see <a href="https://docs.docker.com/engine/reference/run/#network-settings">Network
    /// settings</a> in the <i>Docker run reference</i>.</p>
    pub network_mode: &'a std::option::Option<crate::model::NetworkMode>,
    /// <p>A list of container definitions in JSON format that describe the different containers
    /// that make up your task.</p>
    pub container_definitions:
        &'a std::option::Option<std::vec::Vec<crate::model::ContainerDefinition>>,
    /// <p>A list of volume definitions in JSON format that containers in your task may
    /// use.</p>
    pub volumes: &'a std::option::Option<std::vec::Vec<crate::model::Volume>>,
    /// <p>An array of placement constraint objects to use for the task. You can specify a
    /// maximum of 10 constraints per task (this limit includes constraints in the task
    /// definition and those specified at runtime).</p>
    pub placement_constraints:
        &'a std::option::Option<std::vec::Vec<crate::model::TaskDefinitionPlacementConstraint>>,
    /// <p>The task launch type that Amazon ECS should validate 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.</p>
    pub requires_compatibilities:
        &'a std::option::Option<std::vec::Vec<crate::model::Compatibility>>,
    /// <p>The number of CPU units used by the task. It can be expressed as an integer using CPU
    /// units, for example <code>1024</code>, or as a string using vCPUs, for example <code>1
    /// vCPU</code> or <code>1 vcpu</code>, in a task definition. String values are
    /// converted to an integer indicating the CPU units when the task definition is
    /// registered.</p>
    /// <note>
    /// <p>Task-level CPU and memory parameters are ignored for Windows containers. We
    /// recommend specifying container-level resources for Windows containers.</p>
    /// </note>
    /// <p>If you are using the EC2 launch type, this field is optional. Supported
    /// values are between <code>128</code> CPU units (<code>0.125</code> vCPUs) and
    /// <code>10240</code> CPU units (<code>10</code> vCPUs).</p>
    /// <p>If you are using the Fargate launch type, this field is required and you
    /// must use one of the following values, which determines your range of supported values
    /// for the <code>memory</code> parameter:</p>
    /// <ul>
    /// <li>
    /// <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)</p>
    /// </li>
    /// <li>
    /// <p>512 (.5 vCPU) - Available <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)</p>
    /// </li>
    /// <li>
    /// <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)</p>
    /// </li>
    /// <li>
    /// <p>2048 (2 vCPU) - Available <code>memory</code> values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p>
    /// </li>
    /// <li>
    /// <p>4096 (4 vCPU) - Available <code>memory</code> values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p>
    /// </li>
    /// </ul>
    pub cpu: &'a std::option::Option<std::string::String>,
    /// <p>The amount of memory (in MiB) used by the task. It can be expressed as an integer
    /// using MiB, for example <code>1024</code>, or as a string using GB, for example
    /// <code>1GB</code> or <code>1 GB</code>, in a task definition. String values are
    /// converted to an integer indicating the MiB when the task definition is
    /// registered.</p>
    /// <note>
    /// <p>Task-level CPU and memory parameters are ignored for Windows containers. We
    /// recommend specifying container-level resources for Windows containers.</p>
    /// </note>
    /// <p>If using the EC2 launch type, this field is optional.</p>
    /// <p>If using the Fargate launch type, this field is required and you must
    /// use one of the following values, which determines your range of supported values for the
    /// <code>cpu</code> parameter:</p>
    /// <ul>
    /// <li>
    /// <p>512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 vCPU)</p>
    /// </li>
    /// <li>
    /// <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available <code>cpu</code> values: 512 (.5 vCPU)</p>
    /// </li>
    /// <li>
    /// <p>2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available <code>cpu</code> values: 1024 (1 vCPU)</p>
    /// </li>
    /// <li>
    /// <p>Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 2048 (2 vCPU)</p>
    /// </li>
    /// <li>
    /// <p>Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 4096 (4 vCPU)</p>
    /// </li>
    /// </ul>
    pub memory: &'a std::option::Option<std::string::String>,
    /// <p>The metadata that you apply to the task definition to help you categorize and organize
    /// them. Each tag consists of a key and an optional value, both of which you define.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>The process namespace to use for the containers in the task. The valid
    /// values are <code>host</code> or <code>task</code>. If <code>host</code>
    /// is specified, then all containers within the tasks that specified the
    /// <code>host</code> PID mode on the same container instance share the
    /// same process namespace with the host Amazon EC2 instance. If <code>task</code> is
    /// specified, all containers within the specified task share the same
    /// process namespace. If no value is specified, the default is a private
    /// namespace. For more information, see <a href="https://docs.docker.com/engine/reference/run/#pid-settings---pid">PID settings</a> in the <i>Docker run
    /// reference</i>.</p>
    /// <p>If the <code>host</code> PID mode is used, be aware that there is a
    /// heightened risk of undesired process namespace expose. For more
    /// information, see <a href="https://docs.docker.com/engine/security/security/">Docker
    /// security</a>.</p>
    /// <note>
    /// <p>This parameter is not supported for Windows containers or tasks run on AWS Fargate.</p>
    /// </note>
    pub pid_mode: &'a std::option::Option<crate::model::PidMode>,
    /// <p>The IPC resource namespace to use for the containers in the task. The valid values are
    /// <code>host</code>, <code>task</code>, or <code>none</code>. If <code>host</code> is
    /// specified, then all containers within the tasks that specified the <code>host</code> IPC
    /// mode on the same container instance share the same IPC resources with the host Amazon EC2
    /// instance. If <code>task</code> is specified, all containers within the specified task
    /// share the same IPC resources. If <code>none</code> 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 <a href="https://docs.docker.com/engine/reference/run/#ipc-settings---ipc">IPC
    /// settings</a> in the <i>Docker run reference</i>.</p>
    /// <p>If the <code>host</code> IPC mode is used, be aware that there is a heightened risk of
    /// undesired IPC namespace expose. For more information, see <a href="https://docs.docker.com/engine/security/security/">Docker
    /// security</a>.</p>
    /// <p>If you are setting namespaced kernel parameters using <code>systemControls</code> for
    /// the containers in the task, the following will apply to your IPC resource namespace. For
    /// more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html">System
    /// Controls</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// <ul>
    /// <li>
    /// <p>For tasks that use the <code>host</code> IPC mode, IPC namespace related
    /// <code>systemControls</code> are not supported.</p>
    /// </li>
    /// <li>
    /// <p>For tasks that use the <code>task</code> IPC mode, IPC namespace related
    /// <code>systemControls</code> will apply to all containers within a
    /// task.</p>
    /// </li>
    /// </ul>
    /// <note>
    /// <p>This parameter is not supported for Windows containers or tasks run on AWS Fargate.</p>
    /// </note>
    pub ipc_mode: &'a std::option::Option<crate::model::IpcMode>,
    /// <p>The configuration details for the App Mesh proxy.</p>
    /// <p>For tasks hosted on Amazon EC2 instances, the container instances require at least version
    /// <code>1.26.0</code> of the container agent and at least version
    /// <code>1.26.0-1</code> of the <code>ecs-init</code> package to enable a proxy
    /// configuration. If your container instances are launched from the Amazon ECS-optimized
    /// AMI version <code>20190301</code> or later, then they contain the required versions of
    /// the container agent and <code>ecs-init</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-ami-versions.html">Amazon ECS-optimized AMI versions</a> in the
    /// <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub proxy_configuration: &'a std::option::Option<crate::model::ProxyConfiguration>,
    /// <p>The Elastic Inference accelerators to use for the containers in the task.</p>
    pub inference_accelerators:
        &'a std::option::Option<std::vec::Vec<crate::model::InferenceAccelerator>>,
    /// <p>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 AWS Fargate. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/using_data_volumes.html">Fargate task
    /// storage</a> in the <i>Amazon ECS User Guide for AWS Fargate</i>.</p>
    /// <note>
    /// <p>This parameter is only supported for tasks hosted on AWS Fargate using platform
    /// version <code>1.4.0</code> or later.</p>
    /// </note>
    pub ephemeral_storage: &'a std::option::Option<crate::model::EphemeralStorage>,
}
impl<'a> std::fmt::Debug for RegisterTaskDefinitionInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterTaskDefinitionInputBody");
        formatter.field("family", &self.family);
        formatter.field("task_role_arn", &self.task_role_arn);
        formatter.field("execution_role_arn", &self.execution_role_arn);
        formatter.field("network_mode", &self.network_mode);
        formatter.field("container_definitions", &self.container_definitions);
        formatter.field("volumes", &self.volumes);
        formatter.field("placement_constraints", &self.placement_constraints);
        formatter.field("requires_compatibilities", &self.requires_compatibilities);
        formatter.field("cpu", &self.cpu);
        formatter.field("memory", &self.memory);
        formatter.field("tags", &self.tags);
        formatter.field("pid_mode", &self.pid_mode);
        formatter.field("ipc_mode", &self.ipc_mode);
        formatter.field("proxy_configuration", &self.proxy_configuration);
        formatter.field("inference_accelerators", &self.inference_accelerators);
        formatter.field("ephemeral_storage", &self.ephemeral_storage);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RunTaskInputBody<'a> {
    /// <p>The capacity provider strategy to use for the task.</p>
    /// <p>If a <code>capacityProviderStrategy</code> is specified, the <code>launchType</code>
    /// parameter must be omitted. If no <code>capacityProviderStrategy</code> or
    /// <code>launchType</code> is specified, the
    /// <code>defaultCapacityProviderStrategy</code> for the cluster is used.</p>
    pub capacity_provider_strategy:
        &'a std::option::Option<std::vec::Vec<crate::model::CapacityProviderStrategyItem>>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster on which to run your task.
    /// If you do not specify a cluster, the default cluster is assumed.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The number of instantiations of the specified task to place on your cluster. You can
    /// specify up to 10 tasks per call.</p>
    pub count: &'a std::option::Option<i32>,
    /// <p>Specifies whether to enable Amazon ECS managed tags for the task. For more information, see
    /// <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html">Tagging Your Amazon ECS
    /// Resources</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub enable_ecs_managed_tags: &'a bool,
    /// <p>Whether or not to enable the execute command functionality for the containers in this
    /// task. If <code>true</code>, this enables execute command functionality on all containers
    /// in the task.</p>
    pub enable_execute_command: &'a bool,
    /// <p>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).</p>
    pub group: &'a std::option::Option<std::string::String>,
    /// <p>The infrastructure on which to run your standalone task. For more information, see
    /// <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html">Amazon ECS launch types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// <p>The <code>FARGATE</code> launch type runs your tasks on AWS Fargate On-Demand
    /// infrastructure.</p>
    /// <note>
    /// <p>Fargate Spot infrastructure is available for use but a capacity provider
    /// strategy must be used. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/userguide/fargate-capacity-providers.html">AWS Fargate capacity providers</a> in the
    /// <i>Amazon ECS User Guide for AWS Fargate</i>.</p>
    /// </note>
    /// <p>The <code>EC2</code> launch type runs your tasks on Amazon EC2 instances registered to your
    /// cluster.</p>
    /// <p>The <code>EXTERNAL</code> launch type runs your tasks on your on-premise server or
    /// virtual machine (VM) capacity registered to your cluster.</p>
    /// <p>A task can use either a launch type or a capacity provider strategy. If a
    /// <code>launchType</code> is specified, the <code>capacityProviderStrategy</code>
    /// parameter must be omitted.</p>
    pub launch_type: &'a std::option::Option<crate::model::LaunchType>,
    /// <p>The network configuration for the task. This parameter is required for task
    /// definitions that use the <code>awsvpc</code> network mode to receive their own elastic
    /// network interface, and it is not supported for other network modes. For more
    /// information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task Networking</a>
    /// in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub network_configuration: &'a std::option::Option<crate::model::NetworkConfiguration>,
    /// <p>A list of container overrides in JSON format that specify the name of a container in
    /// the specified task definition and the overrides it should receive. You can override the
    /// default command for a container (that is specified in the task definition or Docker
    /// image) with a <code>command</code> 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 <code>environment</code> override.</p>
    /// <note>
    /// <p>A total of 8192 characters are allowed for overrides. This limit includes the JSON
    /// formatting characters of the override structure.</p>
    /// </note>
    pub overrides: &'a std::option::Option<crate::model::TaskOverride>,
    /// <p>An array of placement constraint objects to use for the task. You can specify up to 10
    /// constraints per task (including constraints in the task definition and those specified
    /// at runtime).</p>
    pub placement_constraints:
        &'a std::option::Option<std::vec::Vec<crate::model::PlacementConstraint>>,
    /// <p>The placement strategy objects to use for the task. You can specify a maximum of five
    /// strategy rules per task.</p>
    pub placement_strategy: &'a std::option::Option<std::vec::Vec<crate::model::PlacementStrategy>>,
    /// <p>The platform version the task should run. A platform version is only specified for
    /// tasks using the Fargate launch type. If one is not specified, the
    /// <code>LATEST</code> platform version is used by default. For more information, see
    /// <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html">AWS Fargate Platform
    /// Versions</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub platform_version: &'a std::option::Option<std::string::String>,
    /// <p>Specifies whether to propagate the tags from the task definition to the task. If no
    /// value is specified, the tags are not propagated. Tags can only be propagated to the task
    /// during task creation. To add tags to a task after task creation, use the <a>TagResource</a> API action.</p>
    /// <note>
    /// <p>An error will be received if you specify the <code>SERVICE</code> option when
    /// running a task.</p>
    /// </note>
    pub propagate_tags: &'a std::option::Option<crate::model::PropagateTags>,
    /// <p>The reference ID to use for the task.</p>
    pub reference_id: &'a std::option::Option<std::string::String>,
    /// <p>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 <code>startedBy</code> parameter. You can then identify which
    /// tasks belong to that job by filtering the results of a <a>ListTasks</a> call
    /// with the <code>startedBy</code> value. Up to 36 letters (uppercase and lowercase),
    /// numbers, hyphens, and underscores are allowed.</p>
    /// <p>If a task is started by an Amazon ECS service, then the <code>startedBy</code> parameter
    /// contains the deployment ID of the service that starts it.</p>
    pub started_by: &'a std::option::Option<std::string::String>,
    /// <p>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.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>The <code>family</code> and <code>revision</code> (<code>family:revision</code>) or
    /// full ARN of the task definition to run. If a <code>revision</code> is not specified,
    /// the latest <code>ACTIVE</code> revision is used.</p>
    pub task_definition: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for RunTaskInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RunTaskInputBody");
        formatter.field(
            "capacity_provider_strategy",
            &self.capacity_provider_strategy,
        );
        formatter.field("cluster", &self.cluster);
        formatter.field("count", &self.count);
        formatter.field("enable_ecs_managed_tags", &self.enable_ecs_managed_tags);
        formatter.field("enable_execute_command", &self.enable_execute_command);
        formatter.field("group", &self.group);
        formatter.field("launch_type", &self.launch_type);
        formatter.field("network_configuration", &self.network_configuration);
        formatter.field("overrides", &self.overrides);
        formatter.field("placement_constraints", &self.placement_constraints);
        formatter.field("placement_strategy", &self.placement_strategy);
        formatter.field("platform_version", &self.platform_version);
        formatter.field("propagate_tags", &self.propagate_tags);
        formatter.field("reference_id", &self.reference_id);
        formatter.field("started_by", &self.started_by);
        formatter.field("tags", &self.tags);
        formatter.field("task_definition", &self.task_definition);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartTaskInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster on which to start your task.
    /// If you do not specify a cluster, the default cluster is assumed.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The container instance IDs or full ARN entries for the container instances on which
    /// you would like to place your task. You can specify up to 10 container instances.</p>
    pub container_instances: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Specifies whether to enable Amazon ECS managed tags for the task. For more information, see
    /// <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html">Tagging Your Amazon ECS
    /// Resources</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub enable_ecs_managed_tags: &'a bool,
    /// <p>Whether or not the execute command functionality is enabled for the task. If
    /// <code>true</code>, this enables execute command functionality on all containers in
    /// the task.</p>
    pub enable_execute_command: &'a bool,
    /// <p>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).</p>
    pub group: &'a std::option::Option<std::string::String>,
    /// <p>The VPC subnet and security group configuration for tasks that receive their own
    /// elastic network interface by using the <code>awsvpc</code> networking mode.</p>
    pub network_configuration: &'a std::option::Option<crate::model::NetworkConfiguration>,
    /// <p>A list of container overrides in JSON format that specify the name of a container in
    /// the specified task definition and the overrides it should receive. You can override the
    /// default command for a container (that is specified in the task definition or Docker
    /// image) with a <code>command</code> 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 <code>environment</code> override.</p>
    /// <note>
    /// <p>A total of 8192 characters are allowed for overrides. This limit includes the JSON
    /// formatting characters of the override structure.</p>
    /// </note>
    pub overrides: &'a std::option::Option<crate::model::TaskOverride>,
    /// <p>Specifies whether to propagate the tags from the task definition or the service to the
    /// task. If no value is specified, the tags are not propagated.</p>
    pub propagate_tags: &'a std::option::Option<crate::model::PropagateTags>,
    /// <p>The reference ID to use for the task.</p>
    pub reference_id: &'a std::option::Option<std::string::String>,
    /// <p>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 <code>startedBy</code> parameter. You can then identify which
    /// tasks belong to that job by filtering the results of a <a>ListTasks</a> call
    /// with the <code>startedBy</code> value. Up to 36 letters (uppercase and lowercase),
    /// numbers, hyphens, and underscores are allowed.</p>
    /// <p>If a task is started by an Amazon ECS service, then the <code>startedBy</code> parameter
    /// contains the deployment ID of the service that starts it.</p>
    pub started_by: &'a std::option::Option<std::string::String>,
    /// <p>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.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>The <code>family</code> and <code>revision</code> (<code>family:revision</code>) or
    /// full ARN of the task definition to start. If a <code>revision</code> is not specified,
    /// the latest <code>ACTIVE</code> revision is used.</p>
    pub task_definition: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for StartTaskInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartTaskInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("container_instances", &self.container_instances);
        formatter.field("enable_ecs_managed_tags", &self.enable_ecs_managed_tags);
        formatter.field("enable_execute_command", &self.enable_execute_command);
        formatter.field("group", &self.group);
        formatter.field("network_configuration", &self.network_configuration);
        formatter.field("overrides", &self.overrides);
        formatter.field("propagate_tags", &self.propagate_tags);
        formatter.field("reference_id", &self.reference_id);
        formatter.field("started_by", &self.started_by);
        formatter.field("tags", &self.tags);
        formatter.field("task_definition", &self.task_definition);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StopTaskInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The task ID or full Amazon Resource Name (ARN) of the task to stop.</p>
    pub task: &'a std::option::Option<std::string::String>,
    /// <p>An optional message specified when a task is stopped. For example, if you are using a
    /// custom scheduler, you can use this parameter to specify the reason for stopping the task
    /// here, and the message appears in subsequent <a>DescribeTasks</a> API
    /// operations on this task. Up to 255 characters are allowed in this message.</p>
    pub reason: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for StopTaskInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StopTaskInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("task", &self.task);
        formatter.field("reason", &self.reason);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SubmitAttachmentStateChangesInputBody<'a> {
    /// <p>The short name or full ARN of the cluster that hosts the container instance the
    /// attachment belongs to.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>Any attachments associated with the state change request.</p>
    pub attachments: &'a std::option::Option<std::vec::Vec<crate::model::AttachmentStateChange>>,
}
impl<'a> std::fmt::Debug for SubmitAttachmentStateChangesInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SubmitAttachmentStateChangesInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("attachments", &self.attachments);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SubmitContainerStateChangeInputBody<'a> {
    /// <p>The short name or full ARN of the cluster that hosts the container.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The task ID or full Amazon Resource Name (ARN) of the task that hosts the container.</p>
    pub task: &'a std::option::Option<std::string::String>,
    /// <p>The name of the container.</p>
    pub container_name: &'a std::option::Option<std::string::String>,
    /// <p>The ID of the Docker container.</p>
    pub runtime_id: &'a std::option::Option<std::string::String>,
    /// <p>The status of the state change request.</p>
    pub status: &'a std::option::Option<std::string::String>,
    /// <p>The exit code returned for the state change request.</p>
    pub exit_code: &'a std::option::Option<i32>,
    /// <p>The reason for the state change request.</p>
    pub reason: &'a std::option::Option<std::string::String>,
    /// <p>The network bindings of the container.</p>
    pub network_bindings: &'a std::option::Option<std::vec::Vec<crate::model::NetworkBinding>>,
}
impl<'a> std::fmt::Debug for SubmitContainerStateChangeInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SubmitContainerStateChangeInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("task", &self.task);
        formatter.field("container_name", &self.container_name);
        formatter.field("runtime_id", &self.runtime_id);
        formatter.field("status", &self.status);
        formatter.field("exit_code", &self.exit_code);
        formatter.field("reason", &self.reason);
        formatter.field("network_bindings", &self.network_bindings);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SubmitTaskStateChangeInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the task.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The task ID or full ARN of the task in the state change request.</p>
    pub task: &'a std::option::Option<std::string::String>,
    /// <p>The status of the state change request.</p>
    pub status: &'a std::option::Option<std::string::String>,
    /// <p>The reason for the state change request.</p>
    pub reason: &'a std::option::Option<std::string::String>,
    /// <p>Any containers associated with the state change request.</p>
    pub containers: &'a std::option::Option<std::vec::Vec<crate::model::ContainerStateChange>>,
    /// <p>Any attachments associated with the state change request.</p>
    pub attachments: &'a std::option::Option<std::vec::Vec<crate::model::AttachmentStateChange>>,
    /// <p>The details for the managed agent associated with the task.</p>
    pub managed_agents:
        &'a std::option::Option<std::vec::Vec<crate::model::ManagedAgentStateChange>>,
    /// <p>The Unix timestamp for when the container image pull began.</p>
    pub pull_started_at: &'a std::option::Option<smithy_types::Instant>,
    /// <p>The Unix timestamp for when the container image pull completed.</p>
    pub pull_stopped_at: &'a std::option::Option<smithy_types::Instant>,
    /// <p>The Unix timestamp for when the task execution stopped.</p>
    pub execution_stopped_at: &'a std::option::Option<smithy_types::Instant>,
}
impl<'a> std::fmt::Debug for SubmitTaskStateChangeInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SubmitTaskStateChangeInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("task", &self.task);
        formatter.field("status", &self.status);
        formatter.field("reason", &self.reason);
        formatter.field("containers", &self.containers);
        formatter.field("attachments", &self.attachments);
        formatter.field("managed_agents", &self.managed_agents);
        formatter.field("pull_started_at", &self.pull_started_at);
        formatter.field("pull_stopped_at", &self.pull_stopped_at);
        formatter.field("execution_stopped_at", &self.execution_stopped_at);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct TagResourceInputBody<'a> {
    /// <p>The Amazon Resource Name (ARN) of the resource to which to add tags. Currently, the supported resources
    /// are Amazon ECS capacity providers, tasks, services, task definitions, clusters, and container
    /// instances.</p>
    pub resource_arn: &'a std::option::Option<std::string::String>,
    /// <p>The tags to add to the resource. A tag is an array of key-value pairs.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    pub tags: &'a std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl<'a> std::fmt::Debug for TagResourceInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("TagResourceInputBody");
        formatter.field("resource_arn", &self.resource_arn);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UntagResourceInputBody<'a> {
    /// <p>The Amazon Resource Name (ARN) of the resource from which to delete tags. Currently, the supported
    /// resources are Amazon ECS capacity providers, tasks, services, task definitions, clusters, and
    /// container instances.</p>
    pub resource_arn: &'a std::option::Option<std::string::String>,
    /// <p>The keys of the tags to be removed.</p>
    pub tag_keys: &'a std::option::Option<std::vec::Vec<std::string::String>>,
}
impl<'a> std::fmt::Debug for UntagResourceInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UntagResourceInputBody");
        formatter.field("resource_arn", &self.resource_arn);
        formatter.field("tag_keys", &self.tag_keys);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateCapacityProviderInputBody<'a> {
    /// <p>The name of the capacity provider to update.</p>
    pub name: &'a std::option::Option<std::string::String>,
    /// <p>An object representing the parameters to update for the Auto Scaling group capacity
    /// provider.</p>
    pub auto_scaling_group_provider:
        &'a std::option::Option<crate::model::AutoScalingGroupProviderUpdate>,
}
impl<'a> std::fmt::Debug for UpdateCapacityProviderInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateCapacityProviderInputBody");
        formatter.field("name", &self.name);
        formatter.field(
            "auto_scaling_group_provider",
            &self.auto_scaling_group_provider,
        );
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateClusterInputBody<'a> {
    /// <p>The name of the cluster to modify the settings for.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The cluster settings for your cluster.</p>
    pub settings: &'a std::option::Option<std::vec::Vec<crate::model::ClusterSetting>>,
    /// <p>The execute command configuration for the cluster.</p>
    pub configuration: &'a std::option::Option<crate::model::ClusterConfiguration>,
}
impl<'a> std::fmt::Debug for UpdateClusterInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateClusterInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("settings", &self.settings);
        formatter.field("configuration", &self.configuration);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateClusterSettingsInputBody<'a> {
    /// <p>The name of the cluster to modify the settings for.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The setting to use by default for a cluster. This parameter is used to enable CloudWatch
    /// Container Insights for a cluster. If this value is specified, it will override the
    /// <code>containerInsights</code> value set with <a>PutAccountSetting</a> or
    /// <a>PutAccountSettingDefault</a>.</p>
    pub settings: &'a std::option::Option<std::vec::Vec<crate::model::ClusterSetting>>,
}
impl<'a> std::fmt::Debug for UpdateClusterSettingsInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateClusterSettingsInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("settings", &self.settings);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateContainerAgentInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The container instance ID or full ARN entries for the container instance on which
    /// you would like to update the Amazon ECS container agent.</p>
    pub container_instance: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for UpdateContainerAgentInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateContainerAgentInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("container_instance", &self.container_instance);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateContainerInstancesStateInputBody<'a> {
    /// <p>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.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>A list of container instance IDs or full ARN entries.</p>
    pub container_instances: &'a std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The container instance state with which to update the container instance. The only
    /// valid values for this action are <code>ACTIVE</code> and <code>DRAINING</code>. A
    /// container instance can only be updated to <code>DRAINING</code> status once it has
    /// reached an <code>ACTIVE</code> state. If a container instance is in
    /// <code>REGISTERING</code>, <code>DEREGISTERING</code>, or
    /// <code>REGISTRATION_FAILED</code> state you can describe the container instance but
    /// will be unable to update the container instance state.</p>
    pub status: &'a std::option::Option<crate::model::ContainerInstanceStatus>,
}
impl<'a> std::fmt::Debug for UpdateContainerInstancesStateInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateContainerInstancesStateInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("container_instances", &self.container_instances);
        formatter.field("status", &self.status);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateServiceInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that your service is running on.
    /// If you do not specify a cluster, the default cluster is assumed.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The name of the service to update.</p>
    pub service: &'a std::option::Option<std::string::String>,
    /// <p>The number of instantiations of the task to place and keep running in your
    /// service.</p>
    pub desired_count: &'a std::option::Option<i32>,
    /// <p>The <code>family</code> and <code>revision</code> (<code>family:revision</code>) or
    /// full ARN of the task definition to run in your service. If a <code>revision</code> is
    /// not specified, the latest <code>ACTIVE</code> revision is used. If you modify the task
    /// definition with <code>UpdateService</code>, 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.</p>
    pub task_definition: &'a std::option::Option<std::string::String>,
    /// <p>The capacity provider strategy to update the service to use.</p>
    /// <p>If the service is using the default capacity provider strategy for the cluster, the
    /// service can be updated to use one or more capacity providers as opposed to the default
    /// capacity provider strategy. However, when a service is using a capacity provider
    /// strategy that is not the default capacity provider strategy, the service cannot be
    /// updated to use the cluster's default capacity provider strategy.</p>
    /// <p>A capacity provider strategy consists of one or more capacity providers along with the
    /// <code>base</code> and <code>weight</code> to assign to them. A capacity provider
    /// must be associated with the cluster to be used in a capacity provider strategy. The
    /// <a>PutClusterCapacityProviders</a> API is used to associate a capacity
    /// provider with a cluster. Only capacity providers with an <code>ACTIVE</code> or
    /// <code>UPDATING</code> status can be used.</p>
    /// <p>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 <a>CreateCapacityProvider</a> API operation.</p>
    /// <p>To use a AWS Fargate capacity provider, specify either the <code>FARGATE</code> or
    /// <code>FARGATE_SPOT</code> capacity providers. The AWS Fargate capacity providers are
    /// available to all accounts and only need to be associated with a cluster to be
    /// used.</p>
    /// <p>The <a>PutClusterCapacityProviders</a> API operation is used to update the
    /// list of available capacity providers for a cluster after the cluster is created.</p>
    /// <p></p>
    pub capacity_provider_strategy:
        &'a std::option::Option<std::vec::Vec<crate::model::CapacityProviderStrategyItem>>,
    /// <p>Optional deployment parameters that control how many tasks run during the deployment
    /// and the ordering of stopping and starting tasks.</p>
    pub deployment_configuration: &'a std::option::Option<crate::model::DeploymentConfiguration>,
    /// <p>An object representing the network configuration for the service.</p>
    pub network_configuration: &'a std::option::Option<crate::model::NetworkConfiguration>,
    /// <p>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.</p>
    /// <p>You can specify a maximum of 10 constraints per task (this limit includes constraints
    /// in the task definition and those specified at runtime).</p>
    pub placement_constraints:
        &'a std::option::Option<std::vec::Vec<crate::model::PlacementConstraint>>,
    /// <p>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.</p>
    /// <p>You can specify a maximum of five strategy rules per service.</p>
    pub placement_strategy: &'a std::option::Option<std::vec::Vec<crate::model::PlacementStrategy>>,
    /// <p>The platform version on which your tasks in the service are running. A platform
    /// version is only specified for tasks using the Fargate launch type. If a
    /// platform version is not specified, the <code>LATEST</code> platform version is used by
    /// default. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html">AWS Fargate Platform
    /// Versions</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    pub platform_version: &'a std::option::Option<std::string::String>,
    /// <p>Whether to force a new deployment of the service. Deployments are not forced by
    /// default. You can use this option to trigger a new deployment with no service definition
    /// changes. For example, you can update a service's tasks to use a newer Docker image with
    /// the same image/tag combination (<code>my_image:latest</code>) or to roll Fargate tasks
    /// onto a newer platform version.</p>
    pub force_new_deployment: &'a bool,
    /// <p>The period of time, in seconds, that the Amazon ECS service scheduler should ignore
    /// unhealthy Elastic Load Balancing target health checks after a task has first started. This is only valid
    /// if your service is configured to use a load balancer. If your service's tasks take a
    /// while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace
    /// period of up to 2,147,483,647 seconds. During that time, the Amazon ECS service
    /// scheduler ignores the Elastic Load Balancing health check status. This grace period can prevent the ECS
    /// service scheduler from marking tasks as unhealthy and stopping them before they have
    /// time to come up.</p>
    pub health_check_grace_period_seconds: &'a std::option::Option<i32>,
    /// <p>If <code>true</code>, this enables execute command functionality on all task
    /// containers.</p>
    /// <p>If you do not want to override the value that was set when the service was created,
    /// you can set this to <code>null</code> when performing this action.</p>
    pub enable_execute_command: &'a std::option::Option<bool>,
}
impl<'a> std::fmt::Debug for UpdateServiceInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateServiceInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("service", &self.service);
        formatter.field("desired_count", &self.desired_count);
        formatter.field("task_definition", &self.task_definition);
        formatter.field(
            "capacity_provider_strategy",
            &self.capacity_provider_strategy,
        );
        formatter.field("deployment_configuration", &self.deployment_configuration);
        formatter.field("network_configuration", &self.network_configuration);
        formatter.field("placement_constraints", &self.placement_constraints);
        formatter.field("placement_strategy", &self.placement_strategy);
        formatter.field("platform_version", &self.platform_version);
        formatter.field("force_new_deployment", &self.force_new_deployment);
        formatter.field(
            "health_check_grace_period_seconds",
            &self.health_check_grace_period_seconds,
        );
        formatter.field("enable_execute_command", &self.enable_execute_command);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateServicePrimaryTaskSetInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service that the task
    /// set exists in.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the service that the task set exists in.</p>
    pub service: &'a std::option::Option<std::string::String>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the task set to set as the primary task set in the
    /// deployment.</p>
    pub primary_task_set: &'a std::option::Option<std::string::String>,
}
impl<'a> std::fmt::Debug for UpdateServicePrimaryTaskSetInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateServicePrimaryTaskSetInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("service", &self.service);
        formatter.field("primary_task_set", &self.primary_task_set);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateTaskSetInputBody<'a> {
    /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service that the task
    /// set exists in.</p>
    pub cluster: &'a std::option::Option<std::string::String>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the service that the task set exists in.</p>
    pub service: &'a std::option::Option<std::string::String>,
    /// <p>The short name or full Amazon Resource Name (ARN) of the task set to update.</p>
    pub task_set: &'a std::option::Option<std::string::String>,
    /// <p>A floating-point percentage of the desired number of tasks to place and keep running
    /// in the task set.</p>
    pub scale: &'a std::option::Option<crate::model::Scale>,
}
impl<'a> std::fmt::Debug for UpdateTaskSetInputBody<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateTaskSetInputBody");
        formatter.field("cluster", &self.cluster);
        formatter.field("service", &self.service);
        formatter.field("task_set", &self.task_set);
        formatter.field("scale", &self.scale);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateCapacityProviderOutputBody {
    /// <p>The full description of the new capacity provider.</p>
    #[serde(rename = "capacityProvider")]
    #[serde(default)]
    pub capacity_provider: std::option::Option<crate::model::CapacityProvider>,
}
impl std::fmt::Debug for CreateCapacityProviderOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateCapacityProviderOutputBody");
        formatter.field("capacity_provider", &self.capacity_provider);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateClusterOutputBody {
    /// <p>The full description of your new cluster.</p>
    #[serde(rename = "cluster")]
    #[serde(default)]
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl std::fmt::Debug for CreateClusterOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateClusterOutputBody");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateServiceOutputBody {
    /// <p>The full description of your service following the create call.</p>
    /// <p>If a service is using the <code>ECS</code> deployment controller, the
    /// <code>deploymentController</code> and <code>taskSets</code> parameters will not be
    /// returned.</p>
    /// <p>If the service is using the <code>CODE_DEPLOY</code> deployment controller, the
    /// <code>deploymentController</code>, <code>taskSets</code> and
    /// <code>deployments</code> parameters will be returned, however the
    /// <code>deployments</code> parameter will be an empty list.</p>
    #[serde(rename = "service")]
    #[serde(default)]
    pub service: std::option::Option<crate::model::Service>,
}
impl std::fmt::Debug for CreateServiceOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateServiceOutputBody");
        formatter.field("service", &self.service);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateTaskSetOutputBody {
    /// <p>Information about a set of Amazon ECS tasks in either an AWS CodeDeploy or an
    /// <code>EXTERNAL</code> 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.</p>
    #[serde(rename = "taskSet")]
    #[serde(default)]
    pub task_set: std::option::Option<crate::model::TaskSet>,
}
impl std::fmt::Debug for CreateTaskSetOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateTaskSetOutputBody");
        formatter.field("task_set", &self.task_set);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteAccountSettingOutputBody {
    /// <p>The account setting for the specified principal ARN.</p>
    #[serde(rename = "setting")]
    #[serde(default)]
    pub setting: std::option::Option<crate::model::Setting>,
}
impl std::fmt::Debug for DeleteAccountSettingOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteAccountSettingOutputBody");
        formatter.field("setting", &self.setting);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteAttributesOutputBody {
    /// <p>A list of attribute objects that were successfully deleted from your resource.</p>
    #[serde(rename = "attributes")]
    #[serde(default)]
    pub attributes: std::option::Option<std::vec::Vec<crate::model::Attribute>>,
}
impl std::fmt::Debug for DeleteAttributesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteAttributesOutputBody");
        formatter.field("attributes", &self.attributes);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteCapacityProviderOutputBody {
    /// <p>The details of the capacity provider.</p>
    #[serde(rename = "capacityProvider")]
    #[serde(default)]
    pub capacity_provider: std::option::Option<crate::model::CapacityProvider>,
}
impl std::fmt::Debug for DeleteCapacityProviderOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteCapacityProviderOutputBody");
        formatter.field("capacity_provider", &self.capacity_provider);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteClusterOutputBody {
    /// <p>The full description of the deleted cluster.</p>
    #[serde(rename = "cluster")]
    #[serde(default)]
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl std::fmt::Debug for DeleteClusterOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteClusterOutputBody");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteServiceOutputBody {
    /// <p>The full description of the deleted service.</p>
    #[serde(rename = "service")]
    #[serde(default)]
    pub service: std::option::Option<crate::model::Service>,
}
impl std::fmt::Debug for DeleteServiceOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteServiceOutputBody");
        formatter.field("service", &self.service);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteTaskSetOutputBody {
    /// <p>Details about the task set.</p>
    #[serde(rename = "taskSet")]
    #[serde(default)]
    pub task_set: std::option::Option<crate::model::TaskSet>,
}
impl std::fmt::Debug for DeleteTaskSetOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteTaskSetOutputBody");
        formatter.field("task_set", &self.task_set);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterContainerInstanceOutputBody {
    /// <p>The container instance that was deregistered.</p>
    #[serde(rename = "containerInstance")]
    #[serde(default)]
    pub container_instance: std::option::Option<crate::model::ContainerInstance>,
}
impl std::fmt::Debug for DeregisterContainerInstanceOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterContainerInstanceOutputBody");
        formatter.field("container_instance", &self.container_instance);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterTaskDefinitionOutputBody {
    /// <p>The full description of the deregistered task.</p>
    #[serde(rename = "taskDefinition")]
    #[serde(default)]
    pub task_definition: std::option::Option<crate::model::TaskDefinition>,
}
impl std::fmt::Debug for DeregisterTaskDefinitionOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterTaskDefinitionOutputBody");
        formatter.field("task_definition", &self.task_definition);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeCapacityProvidersOutputBody {
    /// <p>The list of capacity providers.</p>
    #[serde(rename = "capacityProviders")]
    #[serde(default)]
    pub capacity_providers: std::option::Option<std::vec::Vec<crate::model::CapacityProvider>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
    /// <p>The <code>nextToken</code> value to include in a future
    /// <code>DescribeCapacityProviders</code> request. When the results of a
    /// <code>DescribeCapacityProviders</code> request exceed <code>maxResults</code>, this
    /// value can be used to retrieve the next page of results. This value is <code>null</code>
    /// when there are no more results to return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeCapacityProvidersOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeCapacityProvidersOutputBody");
        formatter.field("capacity_providers", &self.capacity_providers);
        formatter.field("failures", &self.failures);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeClustersOutputBody {
    /// <p>The list of clusters.</p>
    #[serde(rename = "clusters")]
    #[serde(default)]
    pub clusters: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
}
impl std::fmt::Debug for DescribeClustersOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeClustersOutputBody");
        formatter.field("clusters", &self.clusters);
        formatter.field("failures", &self.failures);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeContainerInstancesOutputBody {
    /// <p>The list of container instances.</p>
    #[serde(rename = "containerInstances")]
    #[serde(default)]
    pub container_instances: std::option::Option<std::vec::Vec<crate::model::ContainerInstance>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
}
impl std::fmt::Debug for DescribeContainerInstancesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeContainerInstancesOutputBody");
        formatter.field("container_instances", &self.container_instances);
        formatter.field("failures", &self.failures);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeServicesOutputBody {
    /// <p>The list of services described.</p>
    #[serde(rename = "services")]
    #[serde(default)]
    pub services: std::option::Option<std::vec::Vec<crate::model::Service>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
}
impl std::fmt::Debug for DescribeServicesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeServicesOutputBody");
        formatter.field("services", &self.services);
        formatter.field("failures", &self.failures);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeTaskDefinitionOutputBody {
    /// <p>The full task definition description.</p>
    #[serde(rename = "taskDefinition")]
    #[serde(default)]
    pub task_definition: std::option::Option<crate::model::TaskDefinition>,
    /// <p>The metadata that is applied to the task definition to help you categorize and
    /// organize them. Each tag consists of a key and an optional value, both of which you
    /// define.</p>
    /// <p>The following basic restrictions apply to tags:</p>
    /// <ul>
    /// <li>
    /// <p>Maximum number of tags per resource - 50</p>
    /// </li>
    /// <li>
    /// <p>For each resource, each tag key must be unique, and each tag key can have only
    /// one value.</p>
    /// </li>
    /// <li>
    /// <p>Maximum key length - 128 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>Maximum value length - 256 Unicode characters in UTF-8</p>
    /// </li>
    /// <li>
    /// <p>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: + - = . _ : / @.</p>
    /// </li>
    /// <li>
    /// <p>Tag keys and values are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
    /// combination of such as a prefix for either keys or values as it is reserved for
    /// AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with
    /// this prefix do not count against your tags per resource limit.</p>
    /// </li>
    /// </ul>
    #[serde(rename = "tags")]
    #[serde(default)]
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl std::fmt::Debug for DescribeTaskDefinitionOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeTaskDefinitionOutputBody");
        formatter.field("task_definition", &self.task_definition);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeTasksOutputBody {
    /// <p>The list of tasks.</p>
    #[serde(rename = "tasks")]
    #[serde(default)]
    pub tasks: std::option::Option<std::vec::Vec<crate::model::Task>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
}
impl std::fmt::Debug for DescribeTasksOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeTasksOutputBody");
        formatter.field("tasks", &self.tasks);
        formatter.field("failures", &self.failures);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeTaskSetsOutputBody {
    /// <p>The list of task sets described.</p>
    #[serde(rename = "taskSets")]
    #[serde(default)]
    pub task_sets: std::option::Option<std::vec::Vec<crate::model::TaskSet>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
}
impl std::fmt::Debug for DescribeTaskSetsOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeTaskSetsOutputBody");
        formatter.field("task_sets", &self.task_sets);
        formatter.field("failures", &self.failures);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct DiscoverPollEndpointOutputBody {
    /// <p>The endpoint for the Amazon ECS agent to poll.</p>
    #[serde(rename = "endpoint")]
    #[serde(default)]
    pub endpoint: std::option::Option<std::string::String>,
    /// <p>The telemetry endpoint for the Amazon ECS agent.</p>
    #[serde(rename = "telemetryEndpoint")]
    #[serde(default)]
    pub telemetry_endpoint: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DiscoverPollEndpointOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DiscoverPollEndpointOutputBody");
        formatter.field("endpoint", &self.endpoint);
        formatter.field("telemetry_endpoint", &self.telemetry_endpoint);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ExecuteCommandOutputBody {
    /// <p>The Amazon Resource Name (ARN) of the cluster.</p>
    #[serde(rename = "clusterArn")]
    #[serde(default)]
    pub cluster_arn: std::option::Option<std::string::String>,
    /// <p>The Amazon Resource Name (ARN) of the container.</p>
    #[serde(rename = "containerArn")]
    #[serde(default)]
    pub container_arn: std::option::Option<std::string::String>,
    /// <p>The name of the container.</p>
    #[serde(rename = "containerName")]
    #[serde(default)]
    pub container_name: std::option::Option<std::string::String>,
    /// <p>Whether or not the execute command session is running in interactive mode. Amazon ECS only
    /// supports initiating interactive sessions, so you must specify <code>true</code> for this
    /// value.</p>
    #[serde(rename = "interactive")]
    #[serde(default)]
    pub interactive: bool,
    /// <p>The details of the SSM session that was created for this instance of
    /// execute-command.</p>
    #[serde(rename = "session")]
    #[serde(default)]
    pub session: std::option::Option<crate::model::Session>,
    /// <p>The Amazon Resource Name (ARN) of the task.</p>
    #[serde(rename = "taskArn")]
    #[serde(default)]
    pub task_arn: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ExecuteCommandOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ExecuteCommandOutputBody");
        formatter.field("cluster_arn", &self.cluster_arn);
        formatter.field("container_arn", &self.container_arn);
        formatter.field("container_name", &self.container_name);
        formatter.field("interactive", &self.interactive);
        formatter.field("session", &self.session);
        formatter.field("task_arn", &self.task_arn);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListAccountSettingsOutputBody {
    /// <p>The account settings for the resource.</p>
    #[serde(rename = "settings")]
    #[serde(default)]
    pub settings: std::option::Option<std::vec::Vec<crate::model::Setting>>,
    /// <p>The <code>nextToken</code> value to include in a future
    /// <code>ListAccountSettings</code> request. When the results of a
    /// <code>ListAccountSettings</code> request exceed <code>maxResults</code>, this value
    /// can be used to retrieve the next page of results. This value is <code>null</code> when
    /// there are no more results to return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListAccountSettingsOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListAccountSettingsOutputBody");
        formatter.field("settings", &self.settings);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListAttributesOutputBody {
    /// <p>A list of attribute objects that meet the criteria of the request.</p>
    #[serde(rename = "attributes")]
    #[serde(default)]
    pub attributes: std::option::Option<std::vec::Vec<crate::model::Attribute>>,
    /// <p>The <code>nextToken</code> value to include in a future <code>ListAttributes</code>
    /// request. When the results of a <code>ListAttributes</code> request exceed
    /// <code>maxResults</code>, this value can be used to retrieve the next page of
    /// results. This value is <code>null</code> when there are no more results to
    /// return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListAttributesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListAttributesOutputBody");
        formatter.field("attributes", &self.attributes);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListClustersOutputBody {
    /// <p>The list of full Amazon Resource Name (ARN) entries for each cluster associated with your
    /// account.</p>
    #[serde(rename = "clusterArns")]
    #[serde(default)]
    pub cluster_arns: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The <code>nextToken</code> value to include in a future <code>ListClusters</code>
    /// request. When the results of a <code>ListClusters</code> request exceed
    /// <code>maxResults</code>, this value can be used to retrieve the next page of
    /// results. This value is <code>null</code> when there are no more results to
    /// return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListClustersOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListClustersOutputBody");
        formatter.field("cluster_arns", &self.cluster_arns);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListContainerInstancesOutputBody {
    /// <p>The list of container instances with full ARN entries for each container instance
    /// associated with the specified cluster.</p>
    #[serde(rename = "containerInstanceArns")]
    #[serde(default)]
    pub container_instance_arns: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The <code>nextToken</code> value to include in a future
    /// <code>ListContainerInstances</code> request. When the results of a
    /// <code>ListContainerInstances</code> request exceed <code>maxResults</code>, this
    /// value can be used to retrieve the next page of results. This value is <code>null</code>
    /// when there are no more results to return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListContainerInstancesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListContainerInstancesOutputBody");
        formatter.field("container_instance_arns", &self.container_instance_arns);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListServicesOutputBody {
    /// <p>The list of full ARN entries for each service associated with the specified
    /// cluster.</p>
    #[serde(rename = "serviceArns")]
    #[serde(default)]
    pub service_arns: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The <code>nextToken</code> value to include in a future <code>ListServices</code>
    /// request. When the results of a <code>ListServices</code> request exceed
    /// <code>maxResults</code>, this value can be used to retrieve the next page of
    /// results. This value is <code>null</code> when there are no more results to
    /// return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListServicesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListServicesOutputBody");
        formatter.field("service_arns", &self.service_arns);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceOutputBody {
    /// <p>The tags for the resource.</p>
    #[serde(rename = "tags")]
    #[serde(default)]
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl std::fmt::Debug for ListTagsForResourceOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsForResourceOutputBody");
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTaskDefinitionFamiliesOutputBody {
    /// <p>The list of task definition family names that match the
    /// <code>ListTaskDefinitionFamilies</code> request.</p>
    #[serde(rename = "families")]
    #[serde(default)]
    pub families: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The <code>nextToken</code> value to include in a future
    /// <code>ListTaskDefinitionFamilies</code> request. When the results of a
    /// <code>ListTaskDefinitionFamilies</code> request exceed <code>maxResults</code>, this
    /// value can be used to retrieve the next page of results. This value is <code>null</code>
    /// when there are no more results to return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListTaskDefinitionFamiliesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTaskDefinitionFamiliesOutputBody");
        formatter.field("families", &self.families);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTaskDefinitionsOutputBody {
    /// <p>The list of task definition Amazon Resource Name (ARN) entries for the <code>ListTaskDefinitions</code>
    /// request.</p>
    #[serde(rename = "taskDefinitionArns")]
    #[serde(default)]
    pub task_definition_arns: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The <code>nextToken</code> value to include in a future
    /// <code>ListTaskDefinitions</code> request. When the results of a
    /// <code>ListTaskDefinitions</code> request exceed <code>maxResults</code>, this value
    /// can be used to retrieve the next page of results. This value is <code>null</code> when
    /// there are no more results to return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListTaskDefinitionsOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTaskDefinitionsOutputBody");
        formatter.field("task_definition_arns", &self.task_definition_arns);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTasksOutputBody {
    /// <p>The list of task ARN entries for the <code>ListTasks</code> request.</p>
    #[serde(rename = "taskArns")]
    #[serde(default)]
    pub task_arns: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The <code>nextToken</code> value to include in a future <code>ListTasks</code>
    /// request. When the results of a <code>ListTasks</code> request exceed
    /// <code>maxResults</code>, this value can be used to retrieve the next page of
    /// results. This value is <code>null</code> when there are no more results to
    /// return.</p>
    #[serde(rename = "nextToken")]
    #[serde(default)]
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListTasksOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTasksOutputBody");
        formatter.field("task_arns", &self.task_arns);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAccountSettingOutputBody {
    /// <p>The current account setting for a resource.</p>
    #[serde(rename = "setting")]
    #[serde(default)]
    pub setting: std::option::Option<crate::model::Setting>,
}
impl std::fmt::Debug for PutAccountSettingOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAccountSettingOutputBody");
        formatter.field("setting", &self.setting);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAccountSettingDefaultOutputBody {
    /// <p>The current setting for a resource.</p>
    #[serde(rename = "setting")]
    #[serde(default)]
    pub setting: std::option::Option<crate::model::Setting>,
}
impl std::fmt::Debug for PutAccountSettingDefaultOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAccountSettingDefaultOutputBody");
        formatter.field("setting", &self.setting);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAttributesOutputBody {
    /// <p>The attributes applied to your resource.</p>
    #[serde(rename = "attributes")]
    #[serde(default)]
    pub attributes: std::option::Option<std::vec::Vec<crate::model::Attribute>>,
}
impl std::fmt::Debug for PutAttributesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAttributesOutputBody");
        formatter.field("attributes", &self.attributes);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct PutClusterCapacityProvidersOutputBody {
    /// <p>Details about the cluster.</p>
    #[serde(rename = "cluster")]
    #[serde(default)]
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl std::fmt::Debug for PutClusterCapacityProvidersOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutClusterCapacityProvidersOutputBody");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterContainerInstanceOutputBody {
    /// <p>The container instance that was registered.</p>
    #[serde(rename = "containerInstance")]
    #[serde(default)]
    pub container_instance: std::option::Option<crate::model::ContainerInstance>,
}
impl std::fmt::Debug for RegisterContainerInstanceOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterContainerInstanceOutputBody");
        formatter.field("container_instance", &self.container_instance);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterTaskDefinitionOutputBody {
    /// <p>The full description of the registered task definition.</p>
    #[serde(rename = "taskDefinition")]
    #[serde(default)]
    pub task_definition: std::option::Option<crate::model::TaskDefinition>,
    /// <p>The list of tags associated with the task definition.</p>
    #[serde(rename = "tags")]
    #[serde(default)]
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl std::fmt::Debug for RegisterTaskDefinitionOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterTaskDefinitionOutputBody");
        formatter.field("task_definition", &self.task_definition);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct RunTaskOutputBody {
    /// <p>A full description of the tasks that were run. The tasks that were successfully placed
    /// on your cluster are described here.</p>
    #[serde(rename = "tasks")]
    #[serde(default)]
    pub tasks: std::option::Option<std::vec::Vec<crate::model::Task>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
}
impl std::fmt::Debug for RunTaskOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RunTaskOutputBody");
        formatter.field("tasks", &self.tasks);
        formatter.field("failures", &self.failures);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct StartTaskOutputBody {
    /// <p>A full description of the tasks that were started. Each task that was successfully
    /// placed on your container instances is described.</p>
    #[serde(rename = "tasks")]
    #[serde(default)]
    pub tasks: std::option::Option<std::vec::Vec<crate::model::Task>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
}
impl std::fmt::Debug for StartTaskOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartTaskOutputBody");
        formatter.field("tasks", &self.tasks);
        formatter.field("failures", &self.failures);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct StopTaskOutputBody {
    /// <p>The task that was stopped.</p>
    #[serde(rename = "task")]
    #[serde(default)]
    pub task: std::option::Option<crate::model::Task>,
}
impl std::fmt::Debug for StopTaskOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StopTaskOutputBody");
        formatter.field("task", &self.task);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct SubmitAttachmentStateChangesOutputBody {
    /// <p>Acknowledgement of the state change.</p>
    #[serde(rename = "acknowledgment")]
    #[serde(default)]
    pub acknowledgment: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for SubmitAttachmentStateChangesOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SubmitAttachmentStateChangesOutputBody");
        formatter.field("acknowledgment", &self.acknowledgment);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct SubmitContainerStateChangeOutputBody {
    /// <p>Acknowledgement of the state change.</p>
    #[serde(rename = "acknowledgment")]
    #[serde(default)]
    pub acknowledgment: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for SubmitContainerStateChangeOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SubmitContainerStateChangeOutputBody");
        formatter.field("acknowledgment", &self.acknowledgment);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct SubmitTaskStateChangeOutputBody {
    /// <p>Acknowledgement of the state change.</p>
    #[serde(rename = "acknowledgment")]
    #[serde(default)]
    pub acknowledgment: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for SubmitTaskStateChangeOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SubmitTaskStateChangeOutputBody");
        formatter.field("acknowledgment", &self.acknowledgment);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateCapacityProviderOutputBody {
    /// <p>Details about the capacity provider.</p>
    #[serde(rename = "capacityProvider")]
    #[serde(default)]
    pub capacity_provider: std::option::Option<crate::model::CapacityProvider>,
}
impl std::fmt::Debug for UpdateCapacityProviderOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateCapacityProviderOutputBody");
        formatter.field("capacity_provider", &self.capacity_provider);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateClusterOutputBody {
    /// <p>Details about the cluster.</p>
    #[serde(rename = "cluster")]
    #[serde(default)]
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl std::fmt::Debug for UpdateClusterOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateClusterOutputBody");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateClusterSettingsOutputBody {
    /// <p>Details about the cluster</p>
    #[serde(rename = "cluster")]
    #[serde(default)]
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl std::fmt::Debug for UpdateClusterSettingsOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateClusterSettingsOutputBody");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateContainerAgentOutputBody {
    /// <p>The container instance for which the container agent was updated.</p>
    #[serde(rename = "containerInstance")]
    #[serde(default)]
    pub container_instance: std::option::Option<crate::model::ContainerInstance>,
}
impl std::fmt::Debug for UpdateContainerAgentOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateContainerAgentOutputBody");
        formatter.field("container_instance", &self.container_instance);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateContainerInstancesStateOutputBody {
    /// <p>The list of container instances.</p>
    #[serde(rename = "containerInstances")]
    #[serde(default)]
    pub container_instances: std::option::Option<std::vec::Vec<crate::model::ContainerInstance>>,
    /// <p>Any failures associated with the call.</p>
    #[serde(rename = "failures")]
    #[serde(default)]
    pub failures: std::option::Option<std::vec::Vec<crate::model::Failure>>,
}
impl std::fmt::Debug for UpdateContainerInstancesStateOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateContainerInstancesStateOutputBody");
        formatter.field("container_instances", &self.container_instances);
        formatter.field("failures", &self.failures);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateServiceOutputBody {
    /// <p>The full description of your service following the update call.</p>
    #[serde(rename = "service")]
    #[serde(default)]
    pub service: std::option::Option<crate::model::Service>,
}
impl std::fmt::Debug for UpdateServiceOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateServiceOutputBody");
        formatter.field("service", &self.service);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateServicePrimaryTaskSetOutputBody {
    /// <p>Details about the task set.</p>
    #[serde(rename = "taskSet")]
    #[serde(default)]
    pub task_set: std::option::Option<crate::model::TaskSet>,
}
impl std::fmt::Debug for UpdateServicePrimaryTaskSetOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateServicePrimaryTaskSetOutputBody");
        formatter.field("task_set", &self.task_set);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::default::Default, serde::Deserialize, std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateTaskSetOutputBody {
    /// <p>Details about the task set.</p>
    #[serde(rename = "taskSet")]
    #[serde(default)]
    pub task_set: std::option::Option<crate::model::TaskSet>,
}
impl std::fmt::Debug for UpdateTaskSetOutputBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateTaskSetOutputBody");
        formatter.field("task_set", &self.task_set);
        formatter.finish()
    }
}
