// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[derive(Debug)]
pub(crate) struct Handle<
    C = aws_smithy_client::erase::DynConnector,
    M = aws_hyper::AwsMiddleware,
    R = aws_smithy_client::retry::Standard,
> {
    client: aws_smithy_client::Client<C, M, R>,
    conf: crate::Config,
}

/// An ergonomic service client for `AWSBatchV20160810`.
///
/// This client allows ergonomic access to a `AWSBatchV20160810`-shaped service.
/// Each method corresponds to an endpoint defined in the service's Smithy model,
/// and the request and response shapes are auto-generated from that same model.
///
/// # Using a Client
///
/// Once you have a client set up, you can access the service's endpoints
/// by calling the appropriate method on [`Client`]. Each such method
/// returns a request builder for that endpoint, with methods for setting
/// the various fields of the request. Once your request is complete, use
/// the `send` method to send the request. `send` returns a future, which
/// you then have to `.await` to get the service's response.
///
/// [builder pattern]: https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder
/// [SigV4-signed requests]: https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html
#[derive(std::fmt::Debug)]
pub struct Client<
    C = aws_smithy_client::erase::DynConnector,
    M = aws_hyper::AwsMiddleware,
    R = aws_smithy_client::retry::Standard,
> {
    handle: std::sync::Arc<Handle<C, M, R>>,
}

impl<C, M, R> std::clone::Clone for Client<C, M, R> {
    fn clone(&self) -> Self {
        Self {
            handle: self.handle.clone(),
        }
    }
}

#[doc(inline)]
pub use aws_smithy_client::Builder;

impl<C, M, R> From<aws_smithy_client::Client<C, M, R>> for Client<C, M, R> {
    fn from(client: aws_smithy_client::Client<C, M, R>) -> Self {
        Self::with_config(client, crate::Config::builder().build())
    }
}

impl<C, M, R> Client<C, M, R> {
    /// Creates a client with the given service configuration.
    pub fn with_config(client: aws_smithy_client::Client<C, M, R>, conf: crate::Config) -> Self {
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }

    /// Returns the client's configuration.
    pub fn conf(&self) -> &crate::Config {
        &self.handle.conf
    }
}
impl<C, M, R> Client<C, M, R>
where
    C: aws_smithy_client::bounds::SmithyConnector,
    M: aws_smithy_client::bounds::SmithyMiddleware<C>,
    R: aws_smithy_client::retry::NewRequestPolicy,
{
    /// Constructs a fluent builder for the `CancelJob` operation.
    ///
    /// See [`CancelJob`](crate::client::fluent_builders::CancelJob) for more information about the
    /// operation and its arguments.
    pub fn cancel_job(&self) -> fluent_builders::CancelJob<C, M, R> {
        fluent_builders::CancelJob::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreateComputeEnvironment` operation.
    ///
    /// See [`CreateComputeEnvironment`](crate::client::fluent_builders::CreateComputeEnvironment) for more information about the
    /// operation and its arguments.
    pub fn create_compute_environment(&self) -> fluent_builders::CreateComputeEnvironment<C, M, R> {
        fluent_builders::CreateComputeEnvironment::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreateJobQueue` operation.
    ///
    /// See [`CreateJobQueue`](crate::client::fluent_builders::CreateJobQueue) for more information about the
    /// operation and its arguments.
    pub fn create_job_queue(&self) -> fluent_builders::CreateJobQueue<C, M, R> {
        fluent_builders::CreateJobQueue::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeleteComputeEnvironment` operation.
    ///
    /// See [`DeleteComputeEnvironment`](crate::client::fluent_builders::DeleteComputeEnvironment) for more information about the
    /// operation and its arguments.
    pub fn delete_compute_environment(&self) -> fluent_builders::DeleteComputeEnvironment<C, M, R> {
        fluent_builders::DeleteComputeEnvironment::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeleteJobQueue` operation.
    ///
    /// See [`DeleteJobQueue`](crate::client::fluent_builders::DeleteJobQueue) for more information about the
    /// operation and its arguments.
    pub fn delete_job_queue(&self) -> fluent_builders::DeleteJobQueue<C, M, R> {
        fluent_builders::DeleteJobQueue::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeregisterJobDefinition` operation.
    ///
    /// See [`DeregisterJobDefinition`](crate::client::fluent_builders::DeregisterJobDefinition) for more information about the
    /// operation and its arguments.
    pub fn deregister_job_definition(&self) -> fluent_builders::DeregisterJobDefinition<C, M, R> {
        fluent_builders::DeregisterJobDefinition::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DescribeComputeEnvironments` operation.
    ///
    /// See [`DescribeComputeEnvironments`](crate::client::fluent_builders::DescribeComputeEnvironments) for more information about the
    /// operation and its arguments.
    pub fn describe_compute_environments(
        &self,
    ) -> fluent_builders::DescribeComputeEnvironments<C, M, R> {
        fluent_builders::DescribeComputeEnvironments::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DescribeJobDefinitions` operation.
    ///
    /// See [`DescribeJobDefinitions`](crate::client::fluent_builders::DescribeJobDefinitions) for more information about the
    /// operation and its arguments.
    pub fn describe_job_definitions(&self) -> fluent_builders::DescribeJobDefinitions<C, M, R> {
        fluent_builders::DescribeJobDefinitions::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DescribeJobQueues` operation.
    ///
    /// See [`DescribeJobQueues`](crate::client::fluent_builders::DescribeJobQueues) for more information about the
    /// operation and its arguments.
    pub fn describe_job_queues(&self) -> fluent_builders::DescribeJobQueues<C, M, R> {
        fluent_builders::DescribeJobQueues::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DescribeJobs` operation.
    ///
    /// See [`DescribeJobs`](crate::client::fluent_builders::DescribeJobs) for more information about the
    /// operation and its arguments.
    pub fn describe_jobs(&self) -> fluent_builders::DescribeJobs<C, M, R> {
        fluent_builders::DescribeJobs::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListJobs` operation.
    ///
    /// See [`ListJobs`](crate::client::fluent_builders::ListJobs) for more information about the
    /// operation and its arguments.
    pub fn list_jobs(&self) -> fluent_builders::ListJobs<C, M, R> {
        fluent_builders::ListJobs::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListTagsForResource` operation.
    ///
    /// See [`ListTagsForResource`](crate::client::fluent_builders::ListTagsForResource) for more information about the
    /// operation and its arguments.
    pub fn list_tags_for_resource(&self) -> fluent_builders::ListTagsForResource<C, M, R> {
        fluent_builders::ListTagsForResource::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `RegisterJobDefinition` operation.
    ///
    /// See [`RegisterJobDefinition`](crate::client::fluent_builders::RegisterJobDefinition) for more information about the
    /// operation and its arguments.
    pub fn register_job_definition(&self) -> fluent_builders::RegisterJobDefinition<C, M, R> {
        fluent_builders::RegisterJobDefinition::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `SubmitJob` operation.
    ///
    /// See [`SubmitJob`](crate::client::fluent_builders::SubmitJob) for more information about the
    /// operation and its arguments.
    pub fn submit_job(&self) -> fluent_builders::SubmitJob<C, M, R> {
        fluent_builders::SubmitJob::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `TagResource` operation.
    ///
    /// See [`TagResource`](crate::client::fluent_builders::TagResource) for more information about the
    /// operation and its arguments.
    pub fn tag_resource(&self) -> fluent_builders::TagResource<C, M, R> {
        fluent_builders::TagResource::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `TerminateJob` operation.
    ///
    /// See [`TerminateJob`](crate::client::fluent_builders::TerminateJob) for more information about the
    /// operation and its arguments.
    pub fn terminate_job(&self) -> fluent_builders::TerminateJob<C, M, R> {
        fluent_builders::TerminateJob::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UntagResource` operation.
    ///
    /// See [`UntagResource`](crate::client::fluent_builders::UntagResource) for more information about the
    /// operation and its arguments.
    pub fn untag_resource(&self) -> fluent_builders::UntagResource<C, M, R> {
        fluent_builders::UntagResource::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UpdateComputeEnvironment` operation.
    ///
    /// See [`UpdateComputeEnvironment`](crate::client::fluent_builders::UpdateComputeEnvironment) for more information about the
    /// operation and its arguments.
    pub fn update_compute_environment(&self) -> fluent_builders::UpdateComputeEnvironment<C, M, R> {
        fluent_builders::UpdateComputeEnvironment::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UpdateJobQueue` operation.
    ///
    /// See [`UpdateJobQueue`](crate::client::fluent_builders::UpdateJobQueue) for more information about the
    /// operation and its arguments.
    pub fn update_job_queue(&self) -> fluent_builders::UpdateJobQueue<C, M, R> {
        fluent_builders::UpdateJobQueue::new(self.handle.clone())
    }
}
pub mod fluent_builders {
    //!
    //! Utilities to ergonomically construct a request to the service.
    //!
    //! Fluent builders are created through the [`Client`](crate::client::Client) by calling
    //! one if its operation methods. After parameters are set using the builder methods,
    //! the `send` method can be called to initiate the request.
    //!
    /// Fluent builder constructing a request to `CancelJob`.
    ///
    /// <p>Cancels a job in an Batch job queue. Jobs that are in the <code>SUBMITTED</code>, <code>PENDING</code>, or
    /// <code>RUNNABLE</code> state are canceled. Jobs that have progressed to <code>STARTING</code> or <code>RUNNING</code>
    /// aren't canceled, but the API operation still succeeds, even if no job is canceled. These jobs must be terminated with
    /// the <a>TerminateJob</a> operation.</p>
    #[derive(std::fmt::Debug)]
    pub struct CancelJob<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::cancel_job_input::Builder,
    }
    impl<C, M, R> CancelJob<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CancelJob`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CancelJobOutput,
            aws_smithy_http::result::SdkError<crate::error::CancelJobError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CancelJobInputOperationOutputAlias,
                crate::output::CancelJobOutput,
                crate::error::CancelJobError,
                crate::input::CancelJobInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The Batch job ID of the job to cancel.</p>
        pub fn job_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_id(inp);
            self
        }
        /// <p>The Batch job ID of the job to cancel.</p>
        pub fn set_job_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_job_id(input);
            self
        }
        /// <p>A message to attach to the job that explains the reason for canceling it. This message is returned by future
        /// <a>DescribeJobs</a> operations on the job. This message is also recorded in the Batch activity
        /// logs.</p>
        pub fn reason(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.reason(inp);
            self
        }
        /// <p>A message to attach to the job that explains the reason for canceling it. This message is returned by future
        /// <a>DescribeJobs</a> operations on the job. This message is also recorded in the Batch activity
        /// logs.</p>
        pub fn set_reason(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_reason(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateComputeEnvironment`.
    ///
    /// <p>Creates an Batch compute environment. You can create <code>MANAGED</code> or <code>UNMANAGED</code> compute
    /// environments. <code>MANAGED</code> compute environments can use Amazon EC2 or Fargate resources.
    /// <code>UNMANAGED</code> compute environments can only use EC2 resources.</p>
    /// <p>In a managed compute environment, Batch manages the capacity and instance types of the compute resources
    /// within the environment. This is based on the compute resource specification that you define or the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">launch template</a> that you
    /// specify when you create the compute environment. Either, you can choose to use EC2 On-Demand Instances and EC2 Spot
    /// Instances. Or, you can use Fargate and Fargate Spot capacity in your managed compute environment. You can
    /// optionally set a maximum price so that Spot Instances only launch when the Spot Instance price is less than a
    /// specified percentage of the On-Demand price.</p>
    /// <note>
    /// <p>Multi-node parallel jobs aren't supported on Spot Instances.</p>
    /// </note>
    /// <p>In an unmanaged compute environment, you can manage your own EC2 compute resources and have a lot of flexibility
    /// with how you configure your compute resources. For example, you can use custom AMIs. However, you must verify that
    /// each of your AMIs meet the Amazon ECS container instance AMI specification. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container_instance_AMIs.html">container instance
    /// AMIs</a> in the <i>Amazon Elastic Container Service Developer Guide</i>. After you created your unmanaged compute environment, you
    /// can use the <a>DescribeComputeEnvironments</a> operation to find the Amazon ECS cluster that's associated with
    /// it. Then, launch your container instances into that Amazon ECS cluster. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_container_instance.html">Launching an Amazon ECS
    /// container instance</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
    /// <note>
    /// <p>Batch doesn't upgrade the AMIs in a compute environment after the environment is created. For example, it
    /// doesn't update the AMIs when a newer version of the Amazon ECS optimized AMI is available. Therefore, you're responsible
    /// for managing the guest operating system (including its updates and security patches) and any additional application
    /// software or utilities that you install on the compute resources. To use a new AMI for your Batch jobs, complete
    /// these steps:</p>
    /// <ol>
    /// <li>
    /// <p>Create a new compute environment with the new AMI.</p>
    /// </li>
    /// <li>
    /// <p>Add the compute environment to an existing job queue.</p>
    /// </li>
    /// <li>
    /// <p>Remove the earlier compute environment from your job queue.</p>
    /// </li>
    /// <li>
    /// <p>Delete the earlier compute environment.</p>
    /// </li>
    /// </ol>
    /// </note>
    #[derive(std::fmt::Debug)]
    pub struct CreateComputeEnvironment<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::create_compute_environment_input::Builder,
    }
    impl<C, M, R> CreateComputeEnvironment<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CreateComputeEnvironment`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CreateComputeEnvironmentOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateComputeEnvironmentError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreateComputeEnvironmentInputOperationOutputAlias,
                crate::output::CreateComputeEnvironmentOutput,
                crate::error::CreateComputeEnvironmentError,
                crate::input::CreateComputeEnvironmentInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name for your compute environment. Up to 128 letters (uppercase and lowercase), numbers, hyphens, and
        /// underscores are allowed.</p>
        pub fn compute_environment_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.compute_environment_name(inp);
            self
        }
        /// <p>The name for your compute environment. Up to 128 letters (uppercase and lowercase), numbers, hyphens, and
        /// underscores are allowed.</p>
        pub fn set_compute_environment_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_compute_environment_name(input);
            self
        }
        /// <p>The type of the compute environment: <code>MANAGED</code> or <code>UNMANAGED</code>. For more information, see
        /// <a href="https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html">Compute Environments</a> in the
        /// <i>Batch User Guide</i>.</p>
        pub fn r#type(mut self, inp: crate::model::CeType) -> Self {
            self.inner = self.inner.r#type(inp);
            self
        }
        /// <p>The type of the compute environment: <code>MANAGED</code> or <code>UNMANAGED</code>. For more information, see
        /// <a href="https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html">Compute Environments</a> in the
        /// <i>Batch User Guide</i>.</p>
        pub fn set_type(mut self, input: std::option::Option<crate::model::CeType>) -> Self {
            self.inner = self.inner.set_type(input);
            self
        }
        /// <p>The state of the compute environment. If the state is <code>ENABLED</code>, then the compute environment accepts
        /// jobs from a queue and can scale out automatically based on queues.</p>
        /// <p>If the state is <code>ENABLED</code>, then the Batch scheduler can attempt to place jobs from an associated
        /// job queue on the compute resources within the environment. If the compute environment is managed, then it can scale
        /// its instances out or in automatically, based on the job queue demand.</p>
        /// <p>If the state is <code>DISABLED</code>, then the Batch scheduler doesn't attempt to place jobs within the
        /// environment. Jobs in a <code>STARTING</code> or <code>RUNNING</code> state continue to progress normally. Managed
        /// compute environments in the <code>DISABLED</code> state don't scale out. However, they scale in to
        /// <code>minvCpus</code> value after instances become idle.</p>
        pub fn state(mut self, inp: crate::model::CeState) -> Self {
            self.inner = self.inner.state(inp);
            self
        }
        /// <p>The state of the compute environment. If the state is <code>ENABLED</code>, then the compute environment accepts
        /// jobs from a queue and can scale out automatically based on queues.</p>
        /// <p>If the state is <code>ENABLED</code>, then the Batch scheduler can attempt to place jobs from an associated
        /// job queue on the compute resources within the environment. If the compute environment is managed, then it can scale
        /// its instances out or in automatically, based on the job queue demand.</p>
        /// <p>If the state is <code>DISABLED</code>, then the Batch scheduler doesn't attempt to place jobs within the
        /// environment. Jobs in a <code>STARTING</code> or <code>RUNNING</code> state continue to progress normally. Managed
        /// compute environments in the <code>DISABLED</code> state don't scale out. However, they scale in to
        /// <code>minvCpus</code> value after instances become idle.</p>
        pub fn set_state(mut self, input: std::option::Option<crate::model::CeState>) -> Self {
            self.inner = self.inner.set_state(input);
            self
        }
        /// <p>Details about the compute resources managed by the compute environment. This parameter is required for managed
        /// compute environments. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html">Compute Environments</a> in the <i>Batch User Guide</i>.</p>
        pub fn compute_resources(mut self, inp: crate::model::ComputeResource) -> Self {
            self.inner = self.inner.compute_resources(inp);
            self
        }
        /// <p>Details about the compute resources managed by the compute environment. This parameter is required for managed
        /// compute environments. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html">Compute Environments</a> in the <i>Batch User Guide</i>.</p>
        pub fn set_compute_resources(
            mut self,
            input: std::option::Option<crate::model::ComputeResource>,
        ) -> Self {
            self.inner = self.inner.set_compute_resources(input);
            self
        }
        /// <p>The full Amazon Resource Name (ARN) of the IAM role that allows Batch to make calls to other Amazon Web Services services on your behalf. For
        /// more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/service_IAM_role.html">Batch service IAM
        /// role</a> in the <i>Batch User Guide</i>.</p>
        /// <important>
        /// <p>If your account already created the Batch service-linked role, that role is used by default for your compute
        /// environment unless you specify a different role here. If the Batch service-linked role doesn't exist in your
        /// account, and no role is specified here, the service attempts to create the Batch service-linked role in your
        /// account.</p>
        /// </important>
        /// <p>If your specified role has a path other than <code>/</code>, then you must specify either the full role ARN
        /// (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>
        /// <note>
        /// <p>Depending on how you created your Batch service role, its ARN might contain the <code>service-role</code>
        /// path prefix. When you only specify the name of the service role, Batch assumes that your ARN doesn't use the
        /// <code>service-role</code> path prefix. Because of this, we recommend that you specify the full ARN of your service
        /// role when you create compute environments.</p>
        /// </note>
        pub fn service_role(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_role(inp);
            self
        }
        /// <p>The full Amazon Resource Name (ARN) of the IAM role that allows Batch to make calls to other Amazon Web Services services on your behalf. For
        /// more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/service_IAM_role.html">Batch service IAM
        /// role</a> in the <i>Batch User Guide</i>.</p>
        /// <important>
        /// <p>If your account already created the Batch service-linked role, that role is used by default for your compute
        /// environment unless you specify a different role here. If the Batch service-linked role doesn't exist in your
        /// account, and no role is specified here, the service attempts to create the Batch service-linked role in your
        /// account.</p>
        /// </important>
        /// <p>If your specified role has a path other than <code>/</code>, then you must specify either the full role ARN
        /// (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>
        /// <note>
        /// <p>Depending on how you created your Batch service role, its ARN might contain the <code>service-role</code>
        /// path prefix. When you only specify the name of the service role, Batch assumes that your ARN doesn't use the
        /// <code>service-role</code> path prefix. Because of this, we recommend that you specify the full ARN of your service
        /// role when you create compute environments.</p>
        /// </note>
        pub fn set_service_role(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_role(input);
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags that you apply to the compute environment to help you categorize and organize your resources. Each tag
        /// consists of a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services Resources</a> in <i>Amazon Web Services General
        /// Reference</i>.</p>
        /// <p>These tags can be updated or removed using the <a href="https://docs.aws.amazon.com/batch/latest/APIReference/API_TagResource.html">TagResource</a> and <a href="https://docs.aws.amazon.com/batch/latest/APIReference/API_UntagResource.html">UntagResource</a> API operations. These tags don't
        /// propagate to the underlying compute resources.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.tags(k, v);
            self
        }
        /// <p>The tags that you apply to the compute environment to help you categorize and organize your resources. Each tag
        /// consists of a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services Resources</a> in <i>Amazon Web Services General
        /// Reference</i>.</p>
        /// <p>These tags can be updated or removed using the <a href="https://docs.aws.amazon.com/batch/latest/APIReference/API_TagResource.html">TagResource</a> and <a href="https://docs.aws.amazon.com/batch/latest/APIReference/API_UntagResource.html">UntagResource</a> API operations. These tags don't
        /// propagate to the underlying compute resources.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateJobQueue`.
    ///
    /// <p>Creates an Batch job queue. When you create a job queue, you associate one or more compute environments to the
    /// queue and assign an order of preference for the compute environments.</p>
    /// <p>You also set a priority to the job queue that determines the order that the Batch scheduler places jobs onto
    /// its associated compute environments. For example, if a compute environment is associated with more than one job
    /// queue, the job queue with a higher priority is given preference for scheduling jobs to that compute
    /// environment.</p>
    #[derive(std::fmt::Debug)]
    pub struct CreateJobQueue<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::create_job_queue_input::Builder,
    }
    impl<C, M, R> CreateJobQueue<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CreateJobQueue`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CreateJobQueueOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateJobQueueError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreateJobQueueInputOperationOutputAlias,
                crate::output::CreateJobQueueOutput,
                crate::error::CreateJobQueueError,
                crate::input::CreateJobQueueInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the job queue. Up to 128 letters (uppercase and lowercase), numbers, and underscores are
        /// allowed.</p>
        pub fn job_queue_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_queue_name(inp);
            self
        }
        /// <p>The name of the job queue. Up to 128 letters (uppercase and lowercase), numbers, and underscores are
        /// allowed.</p>
        pub fn set_job_queue_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_job_queue_name(input);
            self
        }
        /// <p>The state of the job queue. If the job queue state is <code>ENABLED</code>, it is able to accept jobs. If the
        /// job queue state is <code>DISABLED</code>, new jobs can't be added to the queue, but jobs already in the queue can
        /// finish.</p>
        pub fn state(mut self, inp: crate::model::JqState) -> Self {
            self.inner = self.inner.state(inp);
            self
        }
        /// <p>The state of the job queue. If the job queue state is <code>ENABLED</code>, it is able to accept jobs. If the
        /// job queue state is <code>DISABLED</code>, new jobs can't be added to the queue, but jobs already in the queue can
        /// finish.</p>
        pub fn set_state(mut self, input: std::option::Option<crate::model::JqState>) -> Self {
            self.inner = self.inner.set_state(input);
            self
        }
        /// <p>The priority of the job queue. Job queues with a higher priority (or a higher integer value for the
        /// <code>priority</code> parameter) are evaluated first when associated with the same compute environment. Priority is
        /// determined in descending order. For example, a job queue with a priority value of <code>10</code> is given scheduling
        /// preference over a job queue with a priority value of <code>1</code>. All of the compute environments must be either
        /// EC2 (<code>EC2</code> or <code>SPOT</code>) or Fargate (<code>FARGATE</code> or <code>FARGATE_SPOT</code>); EC2 and
        /// Fargate compute environments can't be mixed.</p>
        pub fn priority(mut self, inp: i32) -> Self {
            self.inner = self.inner.priority(inp);
            self
        }
        /// <p>The priority of the job queue. Job queues with a higher priority (or a higher integer value for the
        /// <code>priority</code> parameter) are evaluated first when associated with the same compute environment. Priority is
        /// determined in descending order. For example, a job queue with a priority value of <code>10</code> is given scheduling
        /// preference over a job queue with a priority value of <code>1</code>. All of the compute environments must be either
        /// EC2 (<code>EC2</code> or <code>SPOT</code>) or Fargate (<code>FARGATE</code> or <code>FARGATE_SPOT</code>); EC2 and
        /// Fargate compute environments can't be mixed.</p>
        pub fn set_priority(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_priority(input);
            self
        }
        /// Appends an item to `computeEnvironmentOrder`.
        ///
        /// To override the contents of this collection use [`set_compute_environment_order`](Self::set_compute_environment_order).
        ///
        /// <p>The set of compute environments mapped to a job queue and their order relative to each other. The job scheduler
        /// uses this parameter to determine which compute environment should run a specific job. Compute environments must be in
        /// the <code>VALID</code> state before you can associate them with a job queue. You can associate up to three compute
        /// environments with a job queue. All of the compute environments must be either EC2 (<code>EC2</code> or
        /// <code>SPOT</code>) or Fargate (<code>FARGATE</code> or <code>FARGATE_SPOT</code>); EC2 and Fargate compute
        /// environments can't be mixed.</p>
        /// <note>
        /// <p>All compute environments that are associated with a job queue must share the same architecture. Batch doesn't
        /// support mixing compute environment architecture types in a single job queue.</p>
        /// </note>
        pub fn compute_environment_order(
            mut self,
            inp: impl Into<crate::model::ComputeEnvironmentOrder>,
        ) -> Self {
            self.inner = self.inner.compute_environment_order(inp);
            self
        }
        /// <p>The set of compute environments mapped to a job queue and their order relative to each other. The job scheduler
        /// uses this parameter to determine which compute environment should run a specific job. Compute environments must be in
        /// the <code>VALID</code> state before you can associate them with a job queue. You can associate up to three compute
        /// environments with a job queue. All of the compute environments must be either EC2 (<code>EC2</code> or
        /// <code>SPOT</code>) or Fargate (<code>FARGATE</code> or <code>FARGATE_SPOT</code>); EC2 and Fargate compute
        /// environments can't be mixed.</p>
        /// <note>
        /// <p>All compute environments that are associated with a job queue must share the same architecture. Batch doesn't
        /// support mixing compute environment architecture types in a single job queue.</p>
        /// </note>
        pub fn set_compute_environment_order(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ComputeEnvironmentOrder>>,
        ) -> Self {
            self.inner = self.inner.set_compute_environment_order(input);
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags that you apply to the job queue to help you categorize and organize your resources. Each tag consists
        /// of a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html">Tagging your Batch resources</a> in <i>Batch User Guide</i>.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.tags(k, v);
            self
        }
        /// <p>The tags that you apply to the job queue to help you categorize and organize your resources. Each tag consists
        /// of a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html">Tagging your Batch resources</a> in <i>Batch User Guide</i>.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteComputeEnvironment`.
    ///
    /// <p>Deletes an Batch compute environment.</p>
    /// <p>Before you can delete a compute environment, you must set its state to <code>DISABLED</code> with the <a>UpdateComputeEnvironment</a> API operation and disassociate it from any job queues with the <a>UpdateJobQueue</a> API operation. Compute environments that use Fargate resources must terminate all
    /// active jobs on that compute environment before deleting the compute environment. If this isn't done, the compute
    /// environment enters an invalid state.</p>
    #[derive(std::fmt::Debug)]
    pub struct DeleteComputeEnvironment<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::delete_compute_environment_input::Builder,
    }
    impl<C, M, R> DeleteComputeEnvironment<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DeleteComputeEnvironment`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteComputeEnvironmentOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteComputeEnvironmentError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeleteComputeEnvironmentInputOperationOutputAlias,
                crate::output::DeleteComputeEnvironmentOutput,
                crate::error::DeleteComputeEnvironmentError,
                crate::input::DeleteComputeEnvironmentInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name or Amazon Resource Name (ARN) of the compute environment to delete.</p>
        pub fn compute_environment(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.compute_environment(inp);
            self
        }
        /// <p>The name or Amazon Resource Name (ARN) of the compute environment to delete.</p>
        pub fn set_compute_environment(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_compute_environment(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteJobQueue`.
    ///
    /// <p>Deletes the specified job queue. You must first disable submissions for a queue with the <a>UpdateJobQueue</a> operation. All jobs in the queue are eventually terminated when you delete a job queue.
    /// The jobs are terminated at a rate of about 16 jobs each second.</p>
    /// <p>It's not necessary to disassociate compute environments from a queue before submitting a
    /// <code>DeleteJobQueue</code> request.</p>
    #[derive(std::fmt::Debug)]
    pub struct DeleteJobQueue<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::delete_job_queue_input::Builder,
    }
    impl<C, M, R> DeleteJobQueue<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DeleteJobQueue`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteJobQueueOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteJobQueueError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeleteJobQueueInputOperationOutputAlias,
                crate::output::DeleteJobQueueOutput,
                crate::error::DeleteJobQueueError,
                crate::input::DeleteJobQueueInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The short name or full Amazon Resource Name (ARN) of the queue to delete.</p>
        pub fn job_queue(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_queue(inp);
            self
        }
        /// <p>The short name or full Amazon Resource Name (ARN) of the queue to delete.</p>
        pub fn set_job_queue(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_job_queue(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeregisterJobDefinition`.
    ///
    /// <p>Deregisters an Batch job definition. Job definitions are permanently deleted after 180 days.</p>
    #[derive(std::fmt::Debug)]
    pub struct DeregisterJobDefinition<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::deregister_job_definition_input::Builder,
    }
    impl<C, M, R> DeregisterJobDefinition<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DeregisterJobDefinition`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeregisterJobDefinitionOutput,
            aws_smithy_http::result::SdkError<crate::error::DeregisterJobDefinitionError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeregisterJobDefinitionInputOperationOutputAlias,
                crate::output::DeregisterJobDefinitionOutput,
                crate::error::DeregisterJobDefinitionError,
                crate::input::DeregisterJobDefinitionInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name and revision (<code>name:revision</code>) or full Amazon Resource Name (ARN) of the job definition to deregister.</p>
        pub fn job_definition(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_definition(inp);
            self
        }
        /// <p>The name and revision (<code>name:revision</code>) or full Amazon Resource Name (ARN) of the job definition to deregister.</p>
        pub fn set_job_definition(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_job_definition(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DescribeComputeEnvironments`.
    ///
    /// <p>Describes one or more of your compute environments.</p>
    /// <p>If you're using an unmanaged compute environment, you can use the <code>DescribeComputeEnvironment</code>
    /// operation to determine the <code>ecsClusterArn</code> that you should launch your Amazon ECS container instances
    /// into.</p>
    #[derive(std::fmt::Debug)]
    pub struct DescribeComputeEnvironments<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::describe_compute_environments_input::Builder,
    }
    impl<C, M, R> DescribeComputeEnvironments<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DescribeComputeEnvironments`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DescribeComputeEnvironmentsOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeComputeEnvironmentsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DescribeComputeEnvironmentsInputOperationOutputAlias,
                crate::output::DescribeComputeEnvironmentsOutput,
                crate::error::DescribeComputeEnvironmentsError,
                crate::input::DescribeComputeEnvironmentsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// Appends an item to `computeEnvironments`.
        ///
        /// To override the contents of this collection use [`set_compute_environments`](Self::set_compute_environments).
        ///
        /// <p>A list of up to 100 compute environment names or full Amazon Resource Name (ARN) entries.</p>
        pub fn compute_environments(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.compute_environments(inp);
            self
        }
        /// <p>A list of up to 100 compute environment names or full Amazon Resource Name (ARN) entries.</p>
        pub fn set_compute_environments(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_compute_environments(input);
            self
        }
        /// <p>The maximum number of cluster results returned by <code>DescribeComputeEnvironments</code> in paginated output.
        /// When this parameter is used, <code>DescribeComputeEnvironments</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>DescribeComputeEnvironments</code> request with the returned <code>nextToken</code>
        /// value. This value can be between 1 and 100. If this parameter isn't used, then
        /// <code>DescribeComputeEnvironments</code> returns up to 100 results and a <code>nextToken</code>
        /// value if applicable.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        /// <p>The maximum number of cluster results returned by <code>DescribeComputeEnvironments</code> in paginated output.
        /// When this parameter is used, <code>DescribeComputeEnvironments</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>DescribeComputeEnvironments</code> request with the returned <code>nextToken</code>
        /// value. This value can be between 1 and 100. If this parameter isn't used, then
        /// <code>DescribeComputeEnvironments</code> returns up to 100 results and a <code>nextToken</code>
        /// value if applicable.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>The <code>nextToken</code> value returned from a previous paginated <code>DescribeComputeEnvironments</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. This value is
        /// <code>null</code> when there are no more results to return.</p>
        /// <note>
        /// <p>This token should be treated as an opaque identifier that's only used to
        /// retrieve the next items in a list and not for other programmatic purposes.</p>
        /// </note>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>The <code>nextToken</code> value returned from a previous paginated <code>DescribeComputeEnvironments</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. This value is
        /// <code>null</code> when there are no more results to return.</p>
        /// <note>
        /// <p>This token should be treated as an opaque identifier that's only used to
        /// retrieve the next items in a list and not for other programmatic purposes.</p>
        /// </note>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DescribeJobDefinitions`.
    ///
    /// <p>Describes a list of job definitions. You can specify a <code>status</code> (such as <code>ACTIVE</code>) to only
    /// return job definitions that match that status.</p>
    #[derive(std::fmt::Debug)]
    pub struct DescribeJobDefinitions<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::describe_job_definitions_input::Builder,
    }
    impl<C, M, R> DescribeJobDefinitions<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DescribeJobDefinitions`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DescribeJobDefinitionsOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeJobDefinitionsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DescribeJobDefinitionsInputOperationOutputAlias,
                crate::output::DescribeJobDefinitionsOutput,
                crate::error::DescribeJobDefinitionsError,
                crate::input::DescribeJobDefinitionsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// Appends an item to `jobDefinitions`.
        ///
        /// To override the contents of this collection use [`set_job_definitions`](Self::set_job_definitions).
        ///
        /// <p>A list of up to 100 job definitions. Each
        /// entry in the list can either be an ARN of the form
        /// <code>arn:aws:batch:${Region}:${Account}:job-definition/${JobDefinitionName}:${Revision}</code> or a short version
        /// using the form <code>${JobDefinitionName}:${Revision}</code>.</p>
        pub fn job_definitions(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_definitions(inp);
            self
        }
        /// <p>A list of up to 100 job definitions. Each
        /// entry in the list can either be an ARN of the form
        /// <code>arn:aws:batch:${Region}:${Account}:job-definition/${JobDefinitionName}:${Revision}</code> or a short version
        /// using the form <code>${JobDefinitionName}:${Revision}</code>.</p>
        pub fn set_job_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_job_definitions(input);
            self
        }
        /// <p>The maximum number of results returned by <code>DescribeJobDefinitions</code> in paginated output. When this
        /// parameter is used, <code>DescribeJobDefinitions</code> only returns <code>maxResults</code> results in a single page
        /// and a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending
        /// another <code>DescribeJobDefinitions</code> request with the returned <code>nextToken</code> value. This value can be
        /// between 1 and 100. If this parameter isn't used, then
        /// <code>DescribeJobDefinitions</code> returns up to 100 results and a <code>nextToken</code> value
        /// if applicable.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        /// <p>The maximum number of results returned by <code>DescribeJobDefinitions</code> in paginated output. When this
        /// parameter is used, <code>DescribeJobDefinitions</code> only returns <code>maxResults</code> results in a single page
        /// and a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending
        /// another <code>DescribeJobDefinitions</code> request with the returned <code>nextToken</code> value. This value can be
        /// between 1 and 100. If this parameter isn't used, then
        /// <code>DescribeJobDefinitions</code> returns up to 100 results and a <code>nextToken</code> value
        /// if applicable.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>The name of the job definition to describe.</p>
        pub fn job_definition_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_definition_name(inp);
            self
        }
        /// <p>The name of the job definition to describe.</p>
        pub fn set_job_definition_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_job_definition_name(input);
            self
        }
        /// <p>The status used to filter job definitions.</p>
        pub fn status(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.status(inp);
            self
        }
        /// <p>The status used to filter job definitions.</p>
        pub fn set_status(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_status(input);
            self
        }
        /// <p>The <code>nextToken</code> value returned from a previous paginated <code>DescribeJobDefinitions</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. This value is <code>null</code>
        /// when there are no more results to return.</p>
        /// <note>
        /// <p>This token should be treated as an opaque identifier that's only used to
        /// retrieve the next items in a list and not for other programmatic purposes.</p>
        /// </note>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>The <code>nextToken</code> value returned from a previous paginated <code>DescribeJobDefinitions</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. This value is <code>null</code>
        /// when there are no more results to return.</p>
        /// <note>
        /// <p>This token should be treated as an opaque identifier that's only used to
        /// retrieve the next items in a list and not for other programmatic purposes.</p>
        /// </note>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DescribeJobQueues`.
    ///
    /// <p>Describes one or more of your job queues.</p>
    #[derive(std::fmt::Debug)]
    pub struct DescribeJobQueues<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::describe_job_queues_input::Builder,
    }
    impl<C, M, R> DescribeJobQueues<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DescribeJobQueues`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DescribeJobQueuesOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeJobQueuesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DescribeJobQueuesInputOperationOutputAlias,
                crate::output::DescribeJobQueuesOutput,
                crate::error::DescribeJobQueuesError,
                crate::input::DescribeJobQueuesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// Appends an item to `jobQueues`.
        ///
        /// To override the contents of this collection use [`set_job_queues`](Self::set_job_queues).
        ///
        /// <p>A list of up to 100 queue names or full queue Amazon Resource Name (ARN) entries.</p>
        pub fn job_queues(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_queues(inp);
            self
        }
        /// <p>A list of up to 100 queue names or full queue Amazon Resource Name (ARN) entries.</p>
        pub fn set_job_queues(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_job_queues(input);
            self
        }
        /// <p>The maximum number of results returned by <code>DescribeJobQueues</code> in paginated output. When this
        /// parameter is used, <code>DescribeJobQueues</code> only returns <code>maxResults</code> results in a single page and a
        /// <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another
        /// <code>DescribeJobQueues</code> request with the returned <code>nextToken</code> value. This value can be between
        /// 1 and 100. If this parameter isn't used, then <code>DescribeJobQueues</code> returns up
        /// to 100 results and a <code>nextToken</code> value if applicable.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        /// <p>The maximum number of results returned by <code>DescribeJobQueues</code> in paginated output. When this
        /// parameter is used, <code>DescribeJobQueues</code> only returns <code>maxResults</code> results in a single page and a
        /// <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another
        /// <code>DescribeJobQueues</code> request with the returned <code>nextToken</code> value. This value can be between
        /// 1 and 100. If this parameter isn't used, then <code>DescribeJobQueues</code> returns up
        /// to 100 results and a <code>nextToken</code> value if applicable.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>The <code>nextToken</code> value returned from a previous paginated <code>DescribeJobQueues</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. This value is <code>null</code> when
        /// there are no more results to return.</p>
        /// <note>
        /// <p>This token should be treated as an opaque identifier that's only used to
        /// retrieve the next items in a list and not for other programmatic purposes.</p>
        /// </note>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>The <code>nextToken</code> value returned from a previous paginated <code>DescribeJobQueues</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. This value is <code>null</code> when
        /// there are no more results to return.</p>
        /// <note>
        /// <p>This token should be treated as an opaque identifier that's only used to
        /// retrieve the next items in a list and not for other programmatic purposes.</p>
        /// </note>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DescribeJobs`.
    ///
    /// <p>Describes a list of Batch jobs.</p>
    #[derive(std::fmt::Debug)]
    pub struct DescribeJobs<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::describe_jobs_input::Builder,
    }
    impl<C, M, R> DescribeJobs<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DescribeJobs`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DescribeJobsOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeJobsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DescribeJobsInputOperationOutputAlias,
                crate::output::DescribeJobsOutput,
                crate::error::DescribeJobsError,
                crate::input::DescribeJobsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// Appends an item to `jobs`.
        ///
        /// To override the contents of this collection use [`set_jobs`](Self::set_jobs).
        ///
        /// <p>A list of up to 100 job IDs.</p>
        pub fn jobs(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.jobs(inp);
            self
        }
        /// <p>A list of up to 100 job IDs.</p>
        pub fn set_jobs(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_jobs(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListJobs`.
    ///
    /// <p>Returns a list of Batch jobs.</p>
    /// <p>You must specify only one of the following items:</p>
    /// <ul>
    /// <li>
    /// <p>A job queue ID to return a list of jobs in that job queue</p>
    /// </li>
    /// <li>
    /// <p>A multi-node parallel job ID to return a list of nodes for that job</p>
    /// </li>
    /// <li>
    /// <p>An array job ID to return a list of the children for that job</p>
    /// </li>
    /// </ul>
    /// <p>You can filter the results by job status with the <code>jobStatus</code> parameter. If you don't specify a
    /// status, only <code>RUNNING</code> jobs are returned.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListJobs<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_jobs_input::Builder,
    }
    impl<C, M, R> ListJobs<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListJobs`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListJobsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListJobsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListJobsInputOperationOutputAlias,
                crate::output::ListJobsOutput,
                crate::error::ListJobsError,
                crate::input::ListJobsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name or full Amazon Resource Name (ARN) of the job queue used to list jobs.</p>
        pub fn job_queue(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_queue(inp);
            self
        }
        /// <p>The name or full Amazon Resource Name (ARN) of the job queue used to list jobs.</p>
        pub fn set_job_queue(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_job_queue(input);
            self
        }
        /// <p>The job ID for an array job. Specifying an array job ID with this parameter lists all child jobs from within the
        /// specified array.</p>
        pub fn array_job_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.array_job_id(inp);
            self
        }
        /// <p>The job ID for an array job. Specifying an array job ID with this parameter lists all child jobs from within the
        /// specified array.</p>
        pub fn set_array_job_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_array_job_id(input);
            self
        }
        /// <p>The job ID for a multi-node parallel job. Specifying a multi-node parallel job ID with this parameter lists all
        /// nodes that are associated with the specified job.</p>
        pub fn multi_node_job_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.multi_node_job_id(inp);
            self
        }
        /// <p>The job ID for a multi-node parallel job. Specifying a multi-node parallel job ID with this parameter lists all
        /// nodes that are associated with the specified job.</p>
        pub fn set_multi_node_job_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_multi_node_job_id(input);
            self
        }
        /// <p>The job status used to filter jobs in the specified queue. If the <code>filters</code> parameter is specified,
        /// the <code>jobStatus</code> parameter is ignored and jobs with any status are returned. If you don't specify a status,
        /// only <code>RUNNING</code> jobs are returned.</p>
        pub fn job_status(mut self, inp: crate::model::JobStatus) -> Self {
            self.inner = self.inner.job_status(inp);
            self
        }
        /// <p>The job status used to filter jobs in the specified queue. If the <code>filters</code> parameter is specified,
        /// the <code>jobStatus</code> parameter is ignored and jobs with any status are returned. If you don't specify a status,
        /// only <code>RUNNING</code> jobs are returned.</p>
        pub fn set_job_status(
            mut self,
            input: std::option::Option<crate::model::JobStatus>,
        ) -> Self {
            self.inner = self.inner.set_job_status(input);
            self
        }
        /// <p>The maximum number of results returned by <code>ListJobs</code> in paginated output. When this parameter is
        /// used, <code>ListJobs</code> only returns <code>maxResults</code> results in a single page and a
        /// <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another
        /// <code>ListJobs</code> request with the returned <code>nextToken</code> value. This value can be between
        /// 1 and 100. If this parameter isn't used, then <code>ListJobs</code> returns up to
        /// 100 results and a <code>nextToken</code> value if applicable.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        /// <p>The maximum number of results returned by <code>ListJobs</code> in paginated output. When this parameter is
        /// used, <code>ListJobs</code> only returns <code>maxResults</code> results in a single page and a
        /// <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another
        /// <code>ListJobs</code> request with the returned <code>nextToken</code> value. This value can be between
        /// 1 and 100. If this parameter isn't used, then <code>ListJobs</code> returns up to
        /// 100 results and a <code>nextToken</code> value if applicable.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>The <code>nextToken</code> value returned from a previous paginated <code>ListJobs</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. This value is <code>null</code> when
        /// there are no more results to return.</p>
        /// <note>
        /// <p>This token should be treated as an opaque identifier that's only used to
        /// retrieve the next items in a list and not for other programmatic purposes.</p>
        /// </note>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>The <code>nextToken</code> value returned from a previous paginated <code>ListJobs</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. This value is <code>null</code> when
        /// there are no more results to return.</p>
        /// <note>
        /// <p>This token should be treated as an opaque identifier that's only used to
        /// retrieve the next items in a list and not for other programmatic purposes.</p>
        /// </note>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// Appends an item to `filters`.
        ///
        /// To override the contents of this collection use [`set_filters`](Self::set_filters).
        ///
        /// <p>The filter to apply to the query. Only one filter can be used at a time. When the filter is used,
        /// <code>jobStatus</code> is ignored. The filter doesn't apply to child jobs in an array or multi-node parallel (MNP)
        /// jobs. The results are sorted by the <code>createdAt</code> field, with the most recent jobs being first.</p>
        /// <dl>
        /// <dt>JOB_NAME</dt>
        /// <dd>
        /// <p>The value of the filter is a case-insensitive match for the job name. If the value ends with an asterisk (*),
        /// the filter will match any job name that begins with the string before the '*'. This corresponds to the
        /// <code>jobName</code> value. For example, <code>test1</code> matches both <code>Test1</code> and
        /// <code>test1</code>, and <code>test1*</code> matches both <code>test1</code> and <code>Test10</code>. When the
        /// <code>JOB_NAME</code> filter is used, the results are grouped by the job name and version.</p>
        /// </dd>
        /// <dt>JOB_DEFINITION</dt>
        /// <dd>
        /// <p>The value for the filter is the name or Amazon Resource Name (ARN) of the job definition. This corresponds to the
        /// <code>jobDefinition</code> value. The value is case sensitive. When the value for the filter is the job
        /// definition name, the results include all the jobs that used any revision of that job definition name. If the value
        /// ends with an asterisk (*), the filter will match any job definition name that begins with the string before the
        /// '*'. For example, <code>jd1</code> matches only <code>jd1</code>, and <code>jd1*</code> matches both
        /// <code>jd1</code> and <code>jd1A</code>. The version of the job definition that's used doesn't affect the sort
        /// order. When the <code>JOB_DEFINITION</code> filter is used and the ARN is used (which is in the form
        /// <code>arn:${Partition}:batch:${Region}:${Account}:job-definition/${JobDefinitionName}:${Revision}</code>), the
        /// results include jobs that used the specified revision of the job definition. Asterisk (*) is not supported when
        /// the ARN is used.</p>
        /// </dd>
        /// <dt>BEFORE_CREATED_AT</dt>
        /// <dd>
        /// <p>The value for the filter is the time that's before the job was created. This corresponds to the
        /// <code>createdAt</code> value. The value is a string representation of the number of seconds since 00:00:00 UTC
        /// (midnight) on January 1, 1970.</p>
        /// </dd>
        /// <dt>AFTER_CREATED_AT</dt>
        /// <dd>
        /// <p>The value for the filter is the time that's after the job was created. This corresponds to the
        /// <code>createdAt</code> value. The value is a string representation of the number of seconds since 00:00:00 UTC
        /// (midnight) on January 1, 1970.</p>
        /// </dd>
        /// </dl>
        pub fn filters(mut self, inp: impl Into<crate::model::KeyValuesPair>) -> Self {
            self.inner = self.inner.filters(inp);
            self
        }
        /// <p>The filter to apply to the query. Only one filter can be used at a time. When the filter is used,
        /// <code>jobStatus</code> is ignored. The filter doesn't apply to child jobs in an array or multi-node parallel (MNP)
        /// jobs. The results are sorted by the <code>createdAt</code> field, with the most recent jobs being first.</p>
        /// <dl>
        /// <dt>JOB_NAME</dt>
        /// <dd>
        /// <p>The value of the filter is a case-insensitive match for the job name. If the value ends with an asterisk (*),
        /// the filter will match any job name that begins with the string before the '*'. This corresponds to the
        /// <code>jobName</code> value. For example, <code>test1</code> matches both <code>Test1</code> and
        /// <code>test1</code>, and <code>test1*</code> matches both <code>test1</code> and <code>Test10</code>. When the
        /// <code>JOB_NAME</code> filter is used, the results are grouped by the job name and version.</p>
        /// </dd>
        /// <dt>JOB_DEFINITION</dt>
        /// <dd>
        /// <p>The value for the filter is the name or Amazon Resource Name (ARN) of the job definition. This corresponds to the
        /// <code>jobDefinition</code> value. The value is case sensitive. When the value for the filter is the job
        /// definition name, the results include all the jobs that used any revision of that job definition name. If the value
        /// ends with an asterisk (*), the filter will match any job definition name that begins with the string before the
        /// '*'. For example, <code>jd1</code> matches only <code>jd1</code>, and <code>jd1*</code> matches both
        /// <code>jd1</code> and <code>jd1A</code>. The version of the job definition that's used doesn't affect the sort
        /// order. When the <code>JOB_DEFINITION</code> filter is used and the ARN is used (which is in the form
        /// <code>arn:${Partition}:batch:${Region}:${Account}:job-definition/${JobDefinitionName}:${Revision}</code>), the
        /// results include jobs that used the specified revision of the job definition. Asterisk (*) is not supported when
        /// the ARN is used.</p>
        /// </dd>
        /// <dt>BEFORE_CREATED_AT</dt>
        /// <dd>
        /// <p>The value for the filter is the time that's before the job was created. This corresponds to the
        /// <code>createdAt</code> value. The value is a string representation of the number of seconds since 00:00:00 UTC
        /// (midnight) on January 1, 1970.</p>
        /// </dd>
        /// <dt>AFTER_CREATED_AT</dt>
        /// <dd>
        /// <p>The value for the filter is the time that's after the job was created. This corresponds to the
        /// <code>createdAt</code> value. The value is a string representation of the number of seconds since 00:00:00 UTC
        /// (midnight) on January 1, 1970.</p>
        /// </dd>
        /// </dl>
        pub fn set_filters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::KeyValuesPair>>,
        ) -> Self {
            self.inner = self.inner.set_filters(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListTagsForResource`.
    ///
    /// <p>Lists the tags for an Batch resource. Batch resources that support tags are compute environments, jobs, job definitions, and job
    /// queues. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListTagsForResource<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_tags_for_resource_input::Builder,
    }
    impl<C, M, R> ListTagsForResource<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListTagsForResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListTagsForResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::ListTagsForResourceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListTagsForResourceInputOperationOutputAlias,
                crate::output::ListTagsForResourceOutput,
                crate::error::ListTagsForResourceError,
                crate::input::ListTagsForResourceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) that identifies the resource that tags are listed for. Batch resources that support tags are compute environments, jobs, job definitions, and job
        /// queues. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        /// <p>The Amazon Resource Name (ARN) that identifies the resource that tags are listed for. Batch resources that support tags are compute environments, jobs, job definitions, and job
        /// queues. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `RegisterJobDefinition`.
    ///
    /// <p>Registers an Batch job definition.</p>
    #[derive(std::fmt::Debug)]
    pub struct RegisterJobDefinition<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::register_job_definition_input::Builder,
    }
    impl<C, M, R> RegisterJobDefinition<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `RegisterJobDefinition`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::RegisterJobDefinitionOutput,
            aws_smithy_http::result::SdkError<crate::error::RegisterJobDefinitionError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::RegisterJobDefinitionInputOperationOutputAlias,
                crate::output::RegisterJobDefinitionOutput,
                crate::error::RegisterJobDefinitionError,
                crate::input::RegisterJobDefinitionInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the job definition to register. Up to 128 letters (uppercase and lowercase), numbers, hyphens, and
        /// underscores are allowed.</p>
        pub fn job_definition_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_definition_name(inp);
            self
        }
        /// <p>The name of the job definition to register. Up to 128 letters (uppercase and lowercase), numbers, hyphens, and
        /// underscores are allowed.</p>
        pub fn set_job_definition_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_job_definition_name(input);
            self
        }
        /// <p>The type of job definition. For more information about multi-node parallel jobs, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/multi-node-job-def.html">Creating a multi-node parallel job definition</a> in the
        /// <i>Batch User Guide</i>.</p>
        /// <note>
        /// <p>If the job is run on Fargate resources, then <code>multinode</code> isn't supported.</p>
        /// </note>
        pub fn r#type(mut self, inp: crate::model::JobDefinitionType) -> Self {
            self.inner = self.inner.r#type(inp);
            self
        }
        /// <p>The type of job definition. For more information about multi-node parallel jobs, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/multi-node-job-def.html">Creating a multi-node parallel job definition</a> in the
        /// <i>Batch User Guide</i>.</p>
        /// <note>
        /// <p>If the job is run on Fargate resources, then <code>multinode</code> isn't supported.</p>
        /// </note>
        pub fn set_type(
            mut self,
            input: std::option::Option<crate::model::JobDefinitionType>,
        ) -> Self {
            self.inner = self.inner.set_type(input);
            self
        }
        /// Adds a key-value pair to `parameters`.
        ///
        /// To override the contents of this collection use [`set_parameters`](Self::set_parameters).
        ///
        /// <p>Default parameter substitution placeholders to set in the job definition. Parameters are specified as a
        /// key-value pair mapping. Parameters in a <code>SubmitJob</code> request override any corresponding parameter defaults
        /// from the job definition.</p>
        pub fn parameters(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.parameters(k, v);
            self
        }
        /// <p>Default parameter substitution placeholders to set in the job definition. Parameters are specified as a
        /// key-value pair mapping. Parameters in a <code>SubmitJob</code> request override any corresponding parameter defaults
        /// from the job definition.</p>
        pub fn set_parameters(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_parameters(input);
            self
        }
        /// <p>An object with various properties specific to single-node container-based jobs. If the job definition's
        /// <code>type</code> parameter is <code>container</code>, then you must specify either <code>containerProperties</code>
        /// or <code>nodeProperties</code>.</p>
        /// <note>
        /// <p>If the job runs on Fargate resources, then you must not specify <code>nodeProperties</code>; use only
        /// <code>containerProperties</code>.</p>
        /// </note>
        pub fn container_properties(mut self, inp: crate::model::ContainerProperties) -> Self {
            self.inner = self.inner.container_properties(inp);
            self
        }
        /// <p>An object with various properties specific to single-node container-based jobs. If the job definition's
        /// <code>type</code> parameter is <code>container</code>, then you must specify either <code>containerProperties</code>
        /// or <code>nodeProperties</code>.</p>
        /// <note>
        /// <p>If the job runs on Fargate resources, then you must not specify <code>nodeProperties</code>; use only
        /// <code>containerProperties</code>.</p>
        /// </note>
        pub fn set_container_properties(
            mut self,
            input: std::option::Option<crate::model::ContainerProperties>,
        ) -> Self {
            self.inner = self.inner.set_container_properties(input);
            self
        }
        /// <p>An object with various properties specific to multi-node parallel jobs. If you specify node properties for a
        /// job, it becomes a multi-node parallel job. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/multi-node-parallel-jobs.html">Multi-node Parallel Jobs</a> in the
        /// <i>Batch User Guide</i>. If the job definition's <code>type</code> parameter is
        /// <code>container</code>, then you must specify either <code>containerProperties</code> or
        /// <code>nodeProperties</code>.</p>
        /// <note>
        /// <p>If the job runs on Fargate resources, then you must not specify <code>nodeProperties</code>; use
        /// <code>containerProperties</code> instead.</p>
        /// </note>
        pub fn node_properties(mut self, inp: crate::model::NodeProperties) -> Self {
            self.inner = self.inner.node_properties(inp);
            self
        }
        /// <p>An object with various properties specific to multi-node parallel jobs. If you specify node properties for a
        /// job, it becomes a multi-node parallel job. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/multi-node-parallel-jobs.html">Multi-node Parallel Jobs</a> in the
        /// <i>Batch User Guide</i>. If the job definition's <code>type</code> parameter is
        /// <code>container</code>, then you must specify either <code>containerProperties</code> or
        /// <code>nodeProperties</code>.</p>
        /// <note>
        /// <p>If the job runs on Fargate resources, then you must not specify <code>nodeProperties</code>; use
        /// <code>containerProperties</code> instead.</p>
        /// </note>
        pub fn set_node_properties(
            mut self,
            input: std::option::Option<crate::model::NodeProperties>,
        ) -> Self {
            self.inner = self.inner.set_node_properties(input);
            self
        }
        /// <p>The retry strategy to use for failed jobs that are submitted with this job definition. Any retry strategy that's
        /// specified during a <a>SubmitJob</a> operation overrides the retry strategy defined here. If a job is
        /// terminated due to a timeout, it isn't retried.</p>
        pub fn retry_strategy(mut self, inp: crate::model::RetryStrategy) -> Self {
            self.inner = self.inner.retry_strategy(inp);
            self
        }
        /// <p>The retry strategy to use for failed jobs that are submitted with this job definition. Any retry strategy that's
        /// specified during a <a>SubmitJob</a> operation overrides the retry strategy defined here. If a job is
        /// terminated due to a timeout, it isn't retried.</p>
        pub fn set_retry_strategy(
            mut self,
            input: std::option::Option<crate::model::RetryStrategy>,
        ) -> Self {
            self.inner = self.inner.set_retry_strategy(input);
            self
        }
        /// <p>Specifies whether to propagate the tags from the job or job definition to the corresponding Amazon ECS task. If no
        /// value is specified, the tags are not propagated. Tags can only be propagated to the tasks during task creation. For
        /// tags with the same name, job tags are given priority over job definitions tags. If the total number of combined tags
        /// from the job and job definition is over 50, the job is moved to the <code>FAILED</code> state.</p>
        pub fn propagate_tags(mut self, inp: bool) -> Self {
            self.inner = self.inner.propagate_tags(inp);
            self
        }
        /// <p>Specifies whether to propagate the tags from the job or job definition to the corresponding Amazon ECS task. If no
        /// value is specified, the tags are not propagated. Tags can only be propagated to the tasks during task creation. For
        /// tags with the same name, job tags are given priority over job definitions tags. If the total number of combined tags
        /// from the job and job definition is over 50, the job is moved to the <code>FAILED</code> state.</p>
        pub fn set_propagate_tags(mut self, input: std::option::Option<bool>) -> Self {
            self.inner = self.inner.set_propagate_tags(input);
            self
        }
        /// <p>The timeout configuration for jobs that are submitted with this job definition, after which Batch terminates
        /// your jobs if they have not finished. If a job is terminated due to a timeout, it isn't retried. The minimum value for
        /// the timeout is 60 seconds. Any timeout configuration that's specified during a <a>SubmitJob</a> operation
        /// overrides the timeout configuration defined here. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/job_timeouts.html">Job Timeouts</a> in the <i>Batch User Guide</i>.</p>
        pub fn timeout(mut self, inp: crate::model::JobTimeout) -> Self {
            self.inner = self.inner.timeout(inp);
            self
        }
        /// <p>The timeout configuration for jobs that are submitted with this job definition, after which Batch terminates
        /// your jobs if they have not finished. If a job is terminated due to a timeout, it isn't retried. The minimum value for
        /// the timeout is 60 seconds. Any timeout configuration that's specified during a <a>SubmitJob</a> operation
        /// overrides the timeout configuration defined here. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/job_timeouts.html">Job Timeouts</a> in the <i>Batch User Guide</i>.</p>
        pub fn set_timeout(mut self, input: std::option::Option<crate::model::JobTimeout>) -> Self {
            self.inner = self.inner.set_timeout(input);
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags that you apply to the job definition to help you categorize and organize your resources. Each tag
        /// consists of a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html">Tagging Amazon Web Services Resources</a> in <i>Batch User Guide</i>.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.tags(k, v);
            self
        }
        /// <p>The tags that you apply to the job definition to help you categorize and organize your resources. Each tag
        /// consists of a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html">Tagging Amazon Web Services Resources</a> in <i>Batch User Guide</i>.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
        /// Appends an item to `platformCapabilities`.
        ///
        /// To override the contents of this collection use [`set_platform_capabilities`](Self::set_platform_capabilities).
        ///
        /// <p>The platform capabilities required by the job definition. If no value is specified, it defaults to
        /// <code>EC2</code>. To run the job on Fargate resources, specify <code>FARGATE</code>.</p>
        pub fn platform_capabilities(
            mut self,
            inp: impl Into<crate::model::PlatformCapability>,
        ) -> Self {
            self.inner = self.inner.platform_capabilities(inp);
            self
        }
        /// <p>The platform capabilities required by the job definition. If no value is specified, it defaults to
        /// <code>EC2</code>. To run the job on Fargate resources, specify <code>FARGATE</code>.</p>
        pub fn set_platform_capabilities(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::PlatformCapability>>,
        ) -> Self {
            self.inner = self.inner.set_platform_capabilities(input);
            self
        }
    }
    /// Fluent builder constructing a request to `SubmitJob`.
    ///
    /// <p>Submits an Batch job from a job definition. Parameters that are specified during <a>SubmitJob</a>
    /// override parameters defined in the job definition. vCPU and memory requirements that are specified in the
    /// <code>ResourceRequirements</code> objects in the job definition are the exception. They can't be overridden this way
    /// using the <code>memory</code> and <code>vcpus</code> parameters. Rather, you must specify updates to job definition
    /// parameters in a <code>ResourceRequirements</code> object that's included in the <code>containerOverrides</code>
    /// parameter.</p>
    /// <important>
    /// <p>Jobs that run on Fargate resources can't be guaranteed to run for more than 14 days. This is because, after 14
    /// days, Fargate resources might become unavailable and job might be terminated.</p>
    /// </important>
    #[derive(std::fmt::Debug)]
    pub struct SubmitJob<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::submit_job_input::Builder,
    }
    impl<C, M, R> SubmitJob<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `SubmitJob`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::SubmitJobOutput,
            aws_smithy_http::result::SdkError<crate::error::SubmitJobError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::SubmitJobInputOperationOutputAlias,
                crate::output::SubmitJobOutput,
                crate::error::SubmitJobError,
                crate::input::SubmitJobInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the job. The first character must be alphanumeric, and up to 128 letters (uppercase and lowercase),
        /// numbers, hyphens, and underscores are allowed.</p>
        pub fn job_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_name(inp);
            self
        }
        /// <p>The name of the job. The first character must be alphanumeric, and up to 128 letters (uppercase and lowercase),
        /// numbers, hyphens, and underscores are allowed.</p>
        pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_job_name(input);
            self
        }
        /// <p>The job queue where the job is submitted. You can specify either the name or the Amazon Resource Name (ARN) of the queue.</p>
        pub fn job_queue(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_queue(inp);
            self
        }
        /// <p>The job queue where the job is submitted. You can specify either the name or the Amazon Resource Name (ARN) of the queue.</p>
        pub fn set_job_queue(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_job_queue(input);
            self
        }
        /// <p>The array properties for the submitted job, such as the size of the array. The array size can be between 2 and
        /// 10,000. If you specify array properties for a job, it becomes an array job. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/array_jobs.html">Array Jobs</a> in the
        /// <i>Batch User Guide</i>.</p>
        pub fn array_properties(mut self, inp: crate::model::ArrayProperties) -> Self {
            self.inner = self.inner.array_properties(inp);
            self
        }
        /// <p>The array properties for the submitted job, such as the size of the array. The array size can be between 2 and
        /// 10,000. If you specify array properties for a job, it becomes an array job. For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/array_jobs.html">Array Jobs</a> in the
        /// <i>Batch User Guide</i>.</p>
        pub fn set_array_properties(
            mut self,
            input: std::option::Option<crate::model::ArrayProperties>,
        ) -> Self {
            self.inner = self.inner.set_array_properties(input);
            self
        }
        /// Appends an item to `dependsOn`.
        ///
        /// To override the contents of this collection use [`set_depends_on`](Self::set_depends_on).
        ///
        /// <p>A list of dependencies for the job. A job can depend upon a maximum of 20 jobs. You can specify a
        /// <code>SEQUENTIAL</code> type dependency without specifying a job ID for array jobs so that each child array job
        /// completes sequentially, starting at index 0. You can also specify an <code>N_TO_N</code> type dependency with a job
        /// ID for array jobs. In that case, each index child of this job must wait for the corresponding index child of each
        /// dependency to complete before it can begin.</p>
        pub fn depends_on(mut self, inp: impl Into<crate::model::JobDependency>) -> Self {
            self.inner = self.inner.depends_on(inp);
            self
        }
        /// <p>A list of dependencies for the job. A job can depend upon a maximum of 20 jobs. You can specify a
        /// <code>SEQUENTIAL</code> type dependency without specifying a job ID for array jobs so that each child array job
        /// completes sequentially, starting at index 0. You can also specify an <code>N_TO_N</code> type dependency with a job
        /// ID for array jobs. In that case, each index child of this job must wait for the corresponding index child of each
        /// dependency to complete before it can begin.</p>
        pub fn set_depends_on(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::JobDependency>>,
        ) -> Self {
            self.inner = self.inner.set_depends_on(input);
            self
        }
        /// <p>The job definition used by this job. This value can be one of <code>name</code>, <code>name:revision</code>, or
        /// the Amazon Resource Name (ARN) for the job definition. If <code>name</code> is specified without a revision then the latest active
        /// revision is used.</p>
        pub fn job_definition(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_definition(inp);
            self
        }
        /// <p>The job definition used by this job. This value can be one of <code>name</code>, <code>name:revision</code>, or
        /// the Amazon Resource Name (ARN) for the job definition. If <code>name</code> is specified without a revision then the latest active
        /// revision is used.</p>
        pub fn set_job_definition(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_job_definition(input);
            self
        }
        /// Adds a key-value pair to `parameters`.
        ///
        /// To override the contents of this collection use [`set_parameters`](Self::set_parameters).
        ///
        /// <p>Additional parameters passed to the job that replace parameter substitution placeholders that are set in the job
        /// definition. Parameters are specified as a key and value pair mapping. Parameters in a <code>SubmitJob</code> request
        /// override any corresponding parameter defaults from the job definition.</p>
        pub fn parameters(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.parameters(k, v);
            self
        }
        /// <p>Additional parameters passed to the job that replace parameter substitution placeholders that are set in the job
        /// definition. Parameters are specified as a key and value pair mapping. Parameters in a <code>SubmitJob</code> request
        /// override any corresponding parameter defaults from the job definition.</p>
        pub fn set_parameters(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_parameters(input);
            self
        }
        /// <p>A list of container overrides in the JSON format that specify the name of a container in the specified job
        /// definition and the overrides it should receive. You can override the default command for a container, which is
        /// specified in the job definition or the Docker image, with a <code>command</code> override. You can also override
        /// existing environment variables on a container or add new environment variables to it with an <code>environment</code>
        /// override.</p>
        pub fn container_overrides(mut self, inp: crate::model::ContainerOverrides) -> Self {
            self.inner = self.inner.container_overrides(inp);
            self
        }
        /// <p>A list of container overrides in the JSON format that specify the name of a container in the specified job
        /// definition and the overrides it should receive. You can override the default command for a container, which is
        /// specified in the job definition or the Docker image, with a <code>command</code> override. You can also override
        /// existing environment variables on a container or add new environment variables to it with an <code>environment</code>
        /// override.</p>
        pub fn set_container_overrides(
            mut self,
            input: std::option::Option<crate::model::ContainerOverrides>,
        ) -> Self {
            self.inner = self.inner.set_container_overrides(input);
            self
        }
        /// <p>A list of node overrides in JSON format that specify the node range to target and the container overrides for
        /// that node range.</p>
        /// <note>
        /// <p>This parameter isn't applicable to jobs that are running on Fargate resources; use
        /// <code>containerOverrides</code> instead.</p>
        /// </note>
        pub fn node_overrides(mut self, inp: crate::model::NodeOverrides) -> Self {
            self.inner = self.inner.node_overrides(inp);
            self
        }
        /// <p>A list of node overrides in JSON format that specify the node range to target and the container overrides for
        /// that node range.</p>
        /// <note>
        /// <p>This parameter isn't applicable to jobs that are running on Fargate resources; use
        /// <code>containerOverrides</code> instead.</p>
        /// </note>
        pub fn set_node_overrides(
            mut self,
            input: std::option::Option<crate::model::NodeOverrides>,
        ) -> Self {
            self.inner = self.inner.set_node_overrides(input);
            self
        }
        /// <p>The retry strategy to use for failed jobs from this <a>SubmitJob</a> operation. When a retry strategy
        /// is specified here, it overrides the retry strategy defined in the job definition.</p>
        pub fn retry_strategy(mut self, inp: crate::model::RetryStrategy) -> Self {
            self.inner = self.inner.retry_strategy(inp);
            self
        }
        /// <p>The retry strategy to use for failed jobs from this <a>SubmitJob</a> operation. When a retry strategy
        /// is specified here, it overrides the retry strategy defined in the job definition.</p>
        pub fn set_retry_strategy(
            mut self,
            input: std::option::Option<crate::model::RetryStrategy>,
        ) -> Self {
            self.inner = self.inner.set_retry_strategy(input);
            self
        }
        /// <p>Specifies whether to propagate the tags from the job or job definition to the corresponding Amazon ECS task. If no
        /// value is specified, the tags aren't propagated. Tags can only be propagated to the tasks during task creation. For
        /// tags with the same name, job tags are given priority over job definitions tags. If the total number of combined tags
        /// from the job and job definition is over 50, the job is moved to the <code>FAILED</code> state. When specified, this
        /// overrides the tag propagation setting in the job definition.</p>
        pub fn propagate_tags(mut self, inp: bool) -> Self {
            self.inner = self.inner.propagate_tags(inp);
            self
        }
        /// <p>Specifies whether to propagate the tags from the job or job definition to the corresponding Amazon ECS task. If no
        /// value is specified, the tags aren't propagated. Tags can only be propagated to the tasks during task creation. For
        /// tags with the same name, job tags are given priority over job definitions tags. If the total number of combined tags
        /// from the job and job definition is over 50, the job is moved to the <code>FAILED</code> state. When specified, this
        /// overrides the tag propagation setting in the job definition.</p>
        pub fn set_propagate_tags(mut self, input: std::option::Option<bool>) -> Self {
            self.inner = self.inner.set_propagate_tags(input);
            self
        }
        /// <p>The timeout configuration for this <a>SubmitJob</a> operation. You can specify a timeout duration
        /// after which Batch terminates your jobs if they haven't finished. If a job is terminated due to a timeout, it isn't
        /// retried. The minimum value for the timeout is 60 seconds. This configuration overrides any timeout configuration
        /// specified in the job definition. For array jobs, child jobs have the same timeout configuration as the parent job.
        /// For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/job_timeouts.html">Job
        /// Timeouts</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
        pub fn timeout(mut self, inp: crate::model::JobTimeout) -> Self {
            self.inner = self.inner.timeout(inp);
            self
        }
        /// <p>The timeout configuration for this <a>SubmitJob</a> operation. You can specify a timeout duration
        /// after which Batch terminates your jobs if they haven't finished. If a job is terminated due to a timeout, it isn't
        /// retried. The minimum value for the timeout is 60 seconds. This configuration overrides any timeout configuration
        /// specified in the job definition. For array jobs, child jobs have the same timeout configuration as the parent job.
        /// For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/job_timeouts.html">Job
        /// Timeouts</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
        pub fn set_timeout(mut self, input: std::option::Option<crate::model::JobTimeout>) -> Self {
            self.inner = self.inner.set_timeout(input);
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags that you apply to the job request to help you categorize and organize your resources. Each tag consists
        /// of a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services Resources</a> in <i>Amazon Web Services General
        /// Reference</i>.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.tags(k, v);
            self
        }
        /// <p>The tags that you apply to the job request to help you categorize and organize your resources. Each tag consists
        /// of a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services Resources</a> in <i>Amazon Web Services General
        /// Reference</i>.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    /// Fluent builder constructing a request to `TagResource`.
    ///
    /// <p>Associates the specified tags to a resource with the specified <code>resourceArn</code>. If existing tags on a
    /// resource aren't specified in the request parameters, they aren't changed. When a resource is deleted, the tags that
    /// are associated with that resource are deleted as well. Batch resources that support tags are compute environments, jobs, job definitions, and job
    /// queues. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
    #[derive(std::fmt::Debug)]
    pub struct TagResource<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::tag_resource_input::Builder,
    }
    impl<C, M, R> TagResource<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `TagResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::TagResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::TagResourceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::TagResourceInputOperationOutputAlias,
                crate::output::TagResourceOutput,
                crate::error::TagResourceError,
                crate::input::TagResourceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) of the resource that tags are added to. Batch resources that support tags are compute environments, jobs, job definitions, and job
        /// queues. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        /// <p>The Amazon Resource Name (ARN) of the resource that tags are added to. Batch resources that support tags are compute environments, jobs, job definitions, and job
        /// queues. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags that you apply to the resource to help you categorize and organize your resources. Each tag consists of
        /// a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services Resources</a> in <i>Amazon Web Services General
        /// Reference</i>.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.tags(k, v);
            self
        }
        /// <p>The tags that you apply to the resource to help you categorize and organize your resources. Each tag consists of
        /// a key and an optional value. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services Resources</a> in <i>Amazon Web Services General
        /// Reference</i>.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    /// Fluent builder constructing a request to `TerminateJob`.
    ///
    /// <p>Terminates a job in a job queue. Jobs that are in the <code>STARTING</code> or <code>RUNNING</code> state are
    /// terminated, which causes them to transition to <code>FAILED</code>. Jobs that have not progressed to the
    /// <code>STARTING</code> state are cancelled.</p>
    #[derive(std::fmt::Debug)]
    pub struct TerminateJob<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::terminate_job_input::Builder,
    }
    impl<C, M, R> TerminateJob<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `TerminateJob`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::TerminateJobOutput,
            aws_smithy_http::result::SdkError<crate::error::TerminateJobError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::TerminateJobInputOperationOutputAlias,
                crate::output::TerminateJobOutput,
                crate::error::TerminateJobError,
                crate::input::TerminateJobInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The Batch job ID of the job to terminate.</p>
        pub fn job_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_id(inp);
            self
        }
        /// <p>The Batch job ID of the job to terminate.</p>
        pub fn set_job_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_job_id(input);
            self
        }
        /// <p>A message to attach to the job that explains the reason for canceling it. This message is returned by future
        /// <a>DescribeJobs</a> operations on the job. This message is also recorded in the Batch activity
        /// logs.</p>
        pub fn reason(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.reason(inp);
            self
        }
        /// <p>A message to attach to the job that explains the reason for canceling it. This message is returned by future
        /// <a>DescribeJobs</a> operations on the job. This message is also recorded in the Batch activity
        /// logs.</p>
        pub fn set_reason(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_reason(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UntagResource`.
    ///
    /// <p>Deletes specified tags from an Batch resource.</p>
    #[derive(std::fmt::Debug)]
    pub struct UntagResource<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::untag_resource_input::Builder,
    }
    impl<C, M, R> UntagResource<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `UntagResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UntagResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::UntagResourceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UntagResourceInputOperationOutputAlias,
                crate::output::UntagResourceOutput,
                crate::error::UntagResourceError,
                crate::input::UntagResourceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) of the resource from which to delete tags. Batch resources that support tags are compute environments, jobs, job definitions, and job
        /// queues. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        /// <p>The Amazon Resource Name (ARN) of the resource from which to delete tags. Batch resources that support tags are compute environments, jobs, job definitions, and job
        /// queues. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
        /// Appends an item to `tagKeys`.
        ///
        /// To override the contents of this collection use [`set_tag_keys`](Self::set_tag_keys).
        ///
        /// <p>The keys of the tags to be removed.</p>
        pub fn tag_keys(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.tag_keys(inp);
            self
        }
        /// <p>The keys of the tags to be removed.</p>
        pub fn set_tag_keys(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_tag_keys(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateComputeEnvironment`.
    ///
    /// <p>Updates an Batch compute environment.</p>
    #[derive(std::fmt::Debug)]
    pub struct UpdateComputeEnvironment<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::update_compute_environment_input::Builder,
    }
    impl<C, M, R> UpdateComputeEnvironment<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `UpdateComputeEnvironment`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateComputeEnvironmentOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateComputeEnvironmentError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UpdateComputeEnvironmentInputOperationOutputAlias,
                crate::output::UpdateComputeEnvironmentOutput,
                crate::error::UpdateComputeEnvironmentError,
                crate::input::UpdateComputeEnvironmentInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name or full Amazon Resource Name (ARN) of the compute environment to update.</p>
        pub fn compute_environment(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.compute_environment(inp);
            self
        }
        /// <p>The name or full Amazon Resource Name (ARN) of the compute environment to update.</p>
        pub fn set_compute_environment(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_compute_environment(input);
            self
        }
        /// <p>The state of the compute environment. Compute environments in the <code>ENABLED</code> state can accept jobs
        /// from a queue and scale in or out automatically based on the workload demand of its associated queues.</p>
        /// <p>If the state is <code>ENABLED</code>, then the Batch scheduler can attempt to place jobs from an associated
        /// job queue on the compute resources within the environment. If the compute environment is managed, then it can scale
        /// its instances out or in automatically, based on the job queue demand.</p>
        /// <p>If the state is <code>DISABLED</code>, then the Batch scheduler doesn't attempt to place jobs within the
        /// environment. Jobs in a <code>STARTING</code> or <code>RUNNING</code> state continue to progress normally. Managed
        /// compute environments in the <code>DISABLED</code> state don't scale out. However, they scale in to
        /// <code>minvCpus</code> value after instances become idle.</p>
        pub fn state(mut self, inp: crate::model::CeState) -> Self {
            self.inner = self.inner.state(inp);
            self
        }
        /// <p>The state of the compute environment. Compute environments in the <code>ENABLED</code> state can accept jobs
        /// from a queue and scale in or out automatically based on the workload demand of its associated queues.</p>
        /// <p>If the state is <code>ENABLED</code>, then the Batch scheduler can attempt to place jobs from an associated
        /// job queue on the compute resources within the environment. If the compute environment is managed, then it can scale
        /// its instances out or in automatically, based on the job queue demand.</p>
        /// <p>If the state is <code>DISABLED</code>, then the Batch scheduler doesn't attempt to place jobs within the
        /// environment. Jobs in a <code>STARTING</code> or <code>RUNNING</code> state continue to progress normally. Managed
        /// compute environments in the <code>DISABLED</code> state don't scale out. However, they scale in to
        /// <code>minvCpus</code> value after instances become idle.</p>
        pub fn set_state(mut self, input: std::option::Option<crate::model::CeState>) -> Self {
            self.inner = self.inner.set_state(input);
            self
        }
        /// <p>Details of the compute resources managed by the compute environment. Required for a managed compute environment.
        /// For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html">Compute
        /// Environments</a> in the <i>Batch User Guide</i>.</p>
        pub fn compute_resources(mut self, inp: crate::model::ComputeResourceUpdate) -> Self {
            self.inner = self.inner.compute_resources(inp);
            self
        }
        /// <p>Details of the compute resources managed by the compute environment. Required for a managed compute environment.
        /// For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html">Compute
        /// Environments</a> in the <i>Batch User Guide</i>.</p>
        pub fn set_compute_resources(
            mut self,
            input: std::option::Option<crate::model::ComputeResourceUpdate>,
        ) -> Self {
            self.inner = self.inner.set_compute_resources(input);
            self
        }
        /// <p>The full Amazon Resource Name (ARN) of the IAM role that allows Batch to make calls to other Amazon Web Services services on your behalf.
        /// For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/service_IAM_role.html">Batch service IAM
        /// role</a> in the <i>Batch User Guide</i>.</p>
        /// <important>
        /// <p>If the compute environment has a service-linked role, it can't be changed to use a regular IAM role.
        /// Likewise, if the compute environment has a regular IAM role, it can't be changed to use a service-linked
        /// role.</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.</p>
        /// <note>
        /// <p>Depending on how you created your Batch service role, its ARN might contain the <code>service-role</code>
        /// path prefix. When you only specify the name of the service role, Batch assumes that your ARN doesn't use the
        /// <code>service-role</code> path prefix. Because of this, we recommend that you specify the full ARN of your service
        /// role when you create compute environments.</p>
        /// </note>
        pub fn service_role(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_role(inp);
            self
        }
        /// <p>The full Amazon Resource Name (ARN) of the IAM role that allows Batch to make calls to other Amazon Web Services services on your behalf.
        /// For more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/service_IAM_role.html">Batch service IAM
        /// role</a> in the <i>Batch User Guide</i>.</p>
        /// <important>
        /// <p>If the compute environment has a service-linked role, it can't be changed to use a regular IAM role.
        /// Likewise, if the compute environment has a regular IAM role, it can't be changed to use a service-linked
        /// role.</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.</p>
        /// <note>
        /// <p>Depending on how you created your Batch service role, its ARN might contain the <code>service-role</code>
        /// path prefix. When you only specify the name of the service role, Batch assumes that your ARN doesn't use the
        /// <code>service-role</code> path prefix. Because of this, we recommend that you specify the full ARN of your service
        /// role when you create compute environments.</p>
        /// </note>
        pub fn set_service_role(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_role(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateJobQueue`.
    ///
    /// <p>Updates a job queue.</p>
    #[derive(std::fmt::Debug)]
    pub struct UpdateJobQueue<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::update_job_queue_input::Builder,
    }
    impl<C, M, R> UpdateJobQueue<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `UpdateJobQueue`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateJobQueueOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateJobQueueError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UpdateJobQueueInputOperationOutputAlias,
                crate::output::UpdateJobQueueOutput,
                crate::error::UpdateJobQueueError,
                crate::input::UpdateJobQueueInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name or the Amazon Resource Name (ARN) of the job queue.</p>
        pub fn job_queue(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.job_queue(inp);
            self
        }
        /// <p>The name or the Amazon Resource Name (ARN) of the job queue.</p>
        pub fn set_job_queue(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_job_queue(input);
            self
        }
        /// <p>Describes the queue's ability to accept new jobs. If the job queue state is <code>ENABLED</code>, it can accept
        /// jobs. If the job queue state is <code>DISABLED</code>, new jobs can't be added to the queue, but jobs already in the
        /// queue can finish.</p>
        pub fn state(mut self, inp: crate::model::JqState) -> Self {
            self.inner = self.inner.state(inp);
            self
        }
        /// <p>Describes the queue's ability to accept new jobs. If the job queue state is <code>ENABLED</code>, it can accept
        /// jobs. If the job queue state is <code>DISABLED</code>, new jobs can't be added to the queue, but jobs already in the
        /// queue can finish.</p>
        pub fn set_state(mut self, input: std::option::Option<crate::model::JqState>) -> Self {
            self.inner = self.inner.set_state(input);
            self
        }
        /// <p>The priority of the job queue. Job queues with a higher priority (or a higher integer value for the
        /// <code>priority</code> parameter) are evaluated first when associated with the same compute environment. Priority is
        /// determined in descending order, for example, a job queue with a priority value of <code>10</code> is given scheduling
        /// preference over a job queue with a priority value of <code>1</code>. All of the compute environments must be either
        /// EC2 (<code>EC2</code> or <code>SPOT</code>) or Fargate (<code>FARGATE</code> or <code>FARGATE_SPOT</code>). EC2 and
        /// Fargate compute environments can't be mixed.</p>
        pub fn priority(mut self, inp: i32) -> Self {
            self.inner = self.inner.priority(inp);
            self
        }
        /// <p>The priority of the job queue. Job queues with a higher priority (or a higher integer value for the
        /// <code>priority</code> parameter) are evaluated first when associated with the same compute environment. Priority is
        /// determined in descending order, for example, a job queue with a priority value of <code>10</code> is given scheduling
        /// preference over a job queue with a priority value of <code>1</code>. All of the compute environments must be either
        /// EC2 (<code>EC2</code> or <code>SPOT</code>) or Fargate (<code>FARGATE</code> or <code>FARGATE_SPOT</code>). EC2 and
        /// Fargate compute environments can't be mixed.</p>
        pub fn set_priority(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_priority(input);
            self
        }
        /// Appends an item to `computeEnvironmentOrder`.
        ///
        /// To override the contents of this collection use [`set_compute_environment_order`](Self::set_compute_environment_order).
        ///
        /// <p>Details the set of compute environments mapped to a job queue and their order relative to each other. This is
        /// one of the parameters used by the job scheduler to determine which compute environment should run a given job.
        /// Compute environments must be in the <code>VALID</code> state before you can associate them with a job queue. All of
        /// the compute environments must be either EC2 (<code>EC2</code> or <code>SPOT</code>) or Fargate
        /// (<code>FARGATE</code> or <code>FARGATE_SPOT</code>). EC2 and Fargate compute environments can't be mixed.</p>
        /// <note>
        /// <p>All compute environments that are associated with a job queue must share the same architecture. Batch doesn't
        /// support mixing compute environment architecture types in a single job queue.</p>
        /// </note>
        pub fn compute_environment_order(
            mut self,
            inp: impl Into<crate::model::ComputeEnvironmentOrder>,
        ) -> Self {
            self.inner = self.inner.compute_environment_order(inp);
            self
        }
        /// <p>Details the set of compute environments mapped to a job queue and their order relative to each other. This is
        /// one of the parameters used by the job scheduler to determine which compute environment should run a given job.
        /// Compute environments must be in the <code>VALID</code> state before you can associate them with a job queue. All of
        /// the compute environments must be either EC2 (<code>EC2</code> or <code>SPOT</code>) or Fargate
        /// (<code>FARGATE</code> or <code>FARGATE_SPOT</code>). EC2 and Fargate compute environments can't be mixed.</p>
        /// <note>
        /// <p>All compute environments that are associated with a job queue must share the same architecture. Batch doesn't
        /// support mixing compute environment architecture types in a single job queue.</p>
        /// </note>
        pub fn set_compute_environment_order(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ComputeEnvironmentOrder>>,
        ) -> Self {
            self.inner = self.inner.set_compute_environment_order(input);
            self
        }
    }
}
impl<C> Client<C, aws_hyper::AwsMiddleware, aws_smithy_client::retry::Standard> {
    /// Creates a client with the given service config and connector override.
    pub fn from_conf_conn(conf: crate::Config, conn: C) -> Self {
        let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();
        let client = aws_hyper::Client::new(conn).with_retry_config(retry_config.into());
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}
impl
    Client<
        aws_smithy_client::erase::DynConnector,
        aws_hyper::AwsMiddleware,
        aws_smithy_client::retry::Standard,
    >
{
    /// Creates a new client from a shared config.
    #[cfg(any(feature = "rustls", feature = "native-tls"))]
    pub fn new(config: &aws_types::config::Config) -> Self {
        Self::from_conf(config.into())
    }

    /// Creates a new client from the service [`Config`](crate::Config).
    #[cfg(any(feature = "rustls", feature = "native-tls"))]
    pub fn from_conf(conf: crate::Config) -> Self {
        let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();
        let client = aws_hyper::Client::https().with_retry_config(retry_config.into());
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}