// 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 `EtsCustomerService`.
///
/// This client allows ergonomic access to a `EtsCustomerService`-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 `CreateJob` operation.
    ///
    /// See [`CreateJob`](crate::client::fluent_builders::CreateJob) for more information about the
    /// operation and its arguments.
    pub fn create_job(&self) -> fluent_builders::CreateJob<C, M, R> {
        fluent_builders::CreateJob::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreatePipeline` operation.
    ///
    /// See [`CreatePipeline`](crate::client::fluent_builders::CreatePipeline) for more information about the
    /// operation and its arguments.
    pub fn create_pipeline(&self) -> fluent_builders::CreatePipeline<C, M, R> {
        fluent_builders::CreatePipeline::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreatePreset` operation.
    ///
    /// See [`CreatePreset`](crate::client::fluent_builders::CreatePreset) for more information about the
    /// operation and its arguments.
    pub fn create_preset(&self) -> fluent_builders::CreatePreset<C, M, R> {
        fluent_builders::CreatePreset::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeletePipeline` operation.
    ///
    /// See [`DeletePipeline`](crate::client::fluent_builders::DeletePipeline) for more information about the
    /// operation and its arguments.
    pub fn delete_pipeline(&self) -> fluent_builders::DeletePipeline<C, M, R> {
        fluent_builders::DeletePipeline::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeletePreset` operation.
    ///
    /// See [`DeletePreset`](crate::client::fluent_builders::DeletePreset) for more information about the
    /// operation and its arguments.
    pub fn delete_preset(&self) -> fluent_builders::DeletePreset<C, M, R> {
        fluent_builders::DeletePreset::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListJobsByPipeline` operation.
    ///
    /// See [`ListJobsByPipeline`](crate::client::fluent_builders::ListJobsByPipeline) for more information about the
    /// operation and its arguments.
    pub fn list_jobs_by_pipeline(&self) -> fluent_builders::ListJobsByPipeline<C, M, R> {
        fluent_builders::ListJobsByPipeline::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListJobsByStatus` operation.
    ///
    /// See [`ListJobsByStatus`](crate::client::fluent_builders::ListJobsByStatus) for more information about the
    /// operation and its arguments.
    pub fn list_jobs_by_status(&self) -> fluent_builders::ListJobsByStatus<C, M, R> {
        fluent_builders::ListJobsByStatus::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListPipelines` operation.
    ///
    /// See [`ListPipelines`](crate::client::fluent_builders::ListPipelines) for more information about the
    /// operation and its arguments.
    pub fn list_pipelines(&self) -> fluent_builders::ListPipelines<C, M, R> {
        fluent_builders::ListPipelines::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListPresets` operation.
    ///
    /// See [`ListPresets`](crate::client::fluent_builders::ListPresets) for more information about the
    /// operation and its arguments.
    pub fn list_presets(&self) -> fluent_builders::ListPresets<C, M, R> {
        fluent_builders::ListPresets::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ReadJob` operation.
    ///
    /// See [`ReadJob`](crate::client::fluent_builders::ReadJob) for more information about the
    /// operation and its arguments.
    pub fn read_job(&self) -> fluent_builders::ReadJob<C, M, R> {
        fluent_builders::ReadJob::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ReadPipeline` operation.
    ///
    /// See [`ReadPipeline`](crate::client::fluent_builders::ReadPipeline) for more information about the
    /// operation and its arguments.
    pub fn read_pipeline(&self) -> fluent_builders::ReadPipeline<C, M, R> {
        fluent_builders::ReadPipeline::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ReadPreset` operation.
    ///
    /// See [`ReadPreset`](crate::client::fluent_builders::ReadPreset) for more information about the
    /// operation and its arguments.
    pub fn read_preset(&self) -> fluent_builders::ReadPreset<C, M, R> {
        fluent_builders::ReadPreset::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `TestRole` operation.
    ///
    /// See [`TestRole`](crate::client::fluent_builders::TestRole) for more information about the
    /// operation and its arguments.
    pub fn test_role(&self) -> fluent_builders::TestRole<C, M, R> {
        fluent_builders::TestRole::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UpdatePipeline` operation.
    ///
    /// See [`UpdatePipeline`](crate::client::fluent_builders::UpdatePipeline) for more information about the
    /// operation and its arguments.
    pub fn update_pipeline(&self) -> fluent_builders::UpdatePipeline<C, M, R> {
        fluent_builders::UpdatePipeline::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UpdatePipelineNotifications` operation.
    ///
    /// See [`UpdatePipelineNotifications`](crate::client::fluent_builders::UpdatePipelineNotifications) for more information about the
    /// operation and its arguments.
    pub fn update_pipeline_notifications(
        &self,
    ) -> fluent_builders::UpdatePipelineNotifications<C, M, R> {
        fluent_builders::UpdatePipelineNotifications::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UpdatePipelineStatus` operation.
    ///
    /// See [`UpdatePipelineStatus`](crate::client::fluent_builders::UpdatePipelineStatus) for more information about the
    /// operation and its arguments.
    pub fn update_pipeline_status(&self) -> fluent_builders::UpdatePipelineStatus<C, M, R> {
        fluent_builders::UpdatePipelineStatus::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>The CancelJob operation cancels an unfinished job.</p>
    /// <note>
    /// <p>You can only cancel a job that has a status of <code>Submitted</code>. To prevent a
    /// pipeline from starting to process a job while you're getting the job identifier, use
    /// <a>UpdatePipelineStatus</a> to temporarily pause the pipeline.</p>
    /// </note>
    #[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 identifier of the job that you want to cancel.</p>
        /// <p>To get a list of the jobs (including their <code>jobId</code>) that have a status of
        /// <code>Submitted</code>, use the <a>ListJobsByStatus</a> API action.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The identifier of the job that you want to cancel.</p>
        /// <p>To get a list of the jobs (including their <code>jobId</code>) that have a status of
        /// <code>Submitted</code>, use the <a>ListJobsByStatus</a> API action.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateJob`.
    ///
    /// <p>When you create a job, Elastic Transcoder returns JSON data that includes the values that you specified
    /// plus information about the job that is created.</p>
    /// <p>If you have specified more than one output for your jobs (for example, one output for the
    /// Kindle Fire and another output for the Apple iPhone 4s), you currently must use the Elastic Transcoder API to
    /// list the jobs (as opposed to the AWS Console).</p>
    #[derive(std::fmt::Debug)]
    pub struct CreateJob<
        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_input::Builder,
    }
    impl<C, M, R> CreateJob<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 `CreateJob`.
        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::CreateJobOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateJobError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreateJobInputOperationOutputAlias,
                crate::output::CreateJobOutput,
                crate::error::CreateJobError,
                crate::input::CreateJobInputOperationRetryAlias,
            >,
        {
            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 <code>Id</code> of the pipeline that you want Elastic Transcoder to use for
        /// transcoding. The pipeline determines several settings, including the Amazon S3 bucket
        /// from which Elastic Transcoder gets the files to transcode and the bucket into which
        /// Elastic Transcoder puts the transcoded files.</p>
        pub fn pipeline_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.pipeline_id(inp);
            self
        }
        /// <p>The <code>Id</code> of the pipeline that you want Elastic Transcoder to use for
        /// transcoding. The pipeline determines several settings, including the Amazon S3 bucket
        /// from which Elastic Transcoder gets the files to transcode and the bucket into which
        /// Elastic Transcoder puts the transcoded files.</p>
        pub fn set_pipeline_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_pipeline_id(input);
            self
        }
        /// <p>A section of the request body that provides information about the file that is being
        /// transcoded.</p>
        pub fn input(mut self, inp: crate::model::JobInput) -> Self {
            self.inner = self.inner.input(inp);
            self
        }
        /// <p>A section of the request body that provides information about the file that is being
        /// transcoded.</p>
        pub fn set_input(mut self, input: std::option::Option<crate::model::JobInput>) -> Self {
            self.inner = self.inner.set_input(input);
            self
        }
        /// Appends an item to `Inputs`.
        ///
        /// To override the contents of this collection use [`set_inputs`](Self::set_inputs).
        ///
        /// <p>A section of the request body that provides information about the files that are being
        /// transcoded.</p>
        pub fn inputs(mut self, inp: impl Into<crate::model::JobInput>) -> Self {
            self.inner = self.inner.inputs(inp);
            self
        }
        /// <p>A section of the request body that provides information about the files that are being
        /// transcoded.</p>
        pub fn set_inputs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::JobInput>>,
        ) -> Self {
            self.inner = self.inner.set_inputs(input);
            self
        }
        /// <p> A section of the request body that provides information about the transcoded (target)
        /// file. We strongly recommend that you use the <code>Outputs</code> syntax instead of the
        /// <code>Output</code> syntax. </p>
        pub fn output(mut self, inp: crate::model::CreateJobOutput) -> Self {
            self.inner = self.inner.output(inp);
            self
        }
        /// <p> A section of the request body that provides information about the transcoded (target)
        /// file. We strongly recommend that you use the <code>Outputs</code> syntax instead of the
        /// <code>Output</code> syntax. </p>
        pub fn set_output(
            mut self,
            input: std::option::Option<crate::model::CreateJobOutput>,
        ) -> Self {
            self.inner = self.inner.set_output(input);
            self
        }
        /// Appends an item to `Outputs`.
        ///
        /// To override the contents of this collection use [`set_outputs`](Self::set_outputs).
        ///
        /// <p> A section of the request body that provides information about the transcoded (target)
        /// files. We recommend that you use the <code>Outputs</code> syntax instead of the
        /// <code>Output</code> syntax. </p>
        pub fn outputs(mut self, inp: impl Into<crate::model::CreateJobOutput>) -> Self {
            self.inner = self.inner.outputs(inp);
            self
        }
        /// <p> A section of the request body that provides information about the transcoded (target)
        /// files. We recommend that you use the <code>Outputs</code> syntax instead of the
        /// <code>Output</code> syntax. </p>
        pub fn set_outputs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::CreateJobOutput>>,
        ) -> Self {
            self.inner = self.inner.set_outputs(input);
            self
        }
        /// <p>The value, if any, that you want Elastic Transcoder to prepend to the names of all files that this
        /// job creates, including output files, thumbnails, and playlists.</p>
        pub fn output_key_prefix(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.output_key_prefix(inp);
            self
        }
        /// <p>The value, if any, that you want Elastic Transcoder to prepend to the names of all files that this
        /// job creates, including output files, thumbnails, and playlists.</p>
        pub fn set_output_key_prefix(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_output_key_prefix(input);
            self
        }
        /// Appends an item to `Playlists`.
        ///
        /// To override the contents of this collection use [`set_playlists`](Self::set_playlists).
        ///
        /// <p>If you specify a preset in <code>PresetId</code> for which the value of
        /// <code>Container</code> is fmp4 (Fragmented MP4) or ts (MPEG-TS), Playlists contains
        /// information about the master playlists that you want Elastic Transcoder to create.</p>
        /// <p>The maximum number of master playlists in a job is 30.</p>
        pub fn playlists(mut self, inp: impl Into<crate::model::CreateJobPlaylist>) -> Self {
            self.inner = self.inner.playlists(inp);
            self
        }
        /// <p>If you specify a preset in <code>PresetId</code> for which the value of
        /// <code>Container</code> is fmp4 (Fragmented MP4) or ts (MPEG-TS), Playlists contains
        /// information about the master playlists that you want Elastic Transcoder to create.</p>
        /// <p>The maximum number of master playlists in a job is 30.</p>
        pub fn set_playlists(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::CreateJobPlaylist>>,
        ) -> Self {
            self.inner = self.inner.set_playlists(input);
            self
        }
        /// Adds a key-value pair to `UserMetadata`.
        ///
        /// To override the contents of this collection use [`set_user_metadata`](Self::set_user_metadata).
        ///
        /// <p>User-defined metadata that you want to associate with an Elastic Transcoder job. You specify metadata in
        /// <code>key/value</code> pairs, and you can add up to 10 <code>key/value</code> pairs per job.
        /// Elastic Transcoder does not guarantee that <code>key/value</code> pairs are returned in the same
        /// order in which you specify them.</p>
        pub fn user_metadata(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.user_metadata(k, v);
            self
        }
        /// <p>User-defined metadata that you want to associate with an Elastic Transcoder job. You specify metadata in
        /// <code>key/value</code> pairs, and you can add up to 10 <code>key/value</code> pairs per job.
        /// Elastic Transcoder does not guarantee that <code>key/value</code> pairs are returned in the same
        /// order in which you specify them.</p>
        pub fn set_user_metadata(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_user_metadata(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreatePipeline`.
    ///
    /// <p>The CreatePipeline operation creates a pipeline with settings that you specify.</p>
    #[derive(std::fmt::Debug)]
    pub struct CreatePipeline<
        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_pipeline_input::Builder,
    }
    impl<C, M, R> CreatePipeline<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 `CreatePipeline`.
        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::CreatePipelineOutput,
            aws_smithy_http::result::SdkError<crate::error::CreatePipelineError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreatePipelineInputOperationOutputAlias,
                crate::output::CreatePipelineOutput,
                crate::error::CreatePipelineError,
                crate::input::CreatePipelineInputOperationRetryAlias,
            >,
        {
            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 pipeline. We recommend that the name be unique within the AWS account,
        /// but uniqueness is not enforced.</p>
        /// <p>Constraints: Maximum 40 characters.</p>
        pub fn name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(inp);
            self
        }
        /// <p>The name of the pipeline. We recommend that the name be unique within the AWS account,
        /// but uniqueness is not enforced.</p>
        /// <p>Constraints: Maximum 40 characters.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>The Amazon S3 bucket in which you saved the media files that you want to transcode.</p>
        pub fn input_bucket(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.input_bucket(inp);
            self
        }
        /// <p>The Amazon S3 bucket in which you saved the media files that you want to transcode.</p>
        pub fn set_input_bucket(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_input_bucket(input);
            self
        }
        /// <p>The Amazon S3 bucket in which you want Elastic Transcoder to save the transcoded files. (Use
        /// this, or use ContentConfig:Bucket plus ThumbnailConfig:Bucket.)</p>
        /// <p>Specify this value when all of the following are true:</p>
        /// <ul>
        /// <li>
        /// <p>You want to save transcoded files, thumbnails (if any), and playlists (if any)
        /// together in one bucket.</p>
        /// </li>
        /// <li>
        /// <p>You do not want to specify the users or groups who have access to the transcoded
        /// files, thumbnails, and playlists.</p>
        /// </li>
        /// <li>
        /// <p>You do not want to specify the permissions that Elastic Transcoder grants to the   
        ///
        /// files. </p>
        /// <important>
        /// <p>When Elastic Transcoder saves files in
        /// <code>OutputBucket</code>, it grants full control over the files only to
        /// the AWS account that owns the role that is specified by
        /// <code>Role</code>.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>You want to associate the transcoded files and thumbnails with the Amazon S3
        /// Standard storage class.</p>
        /// </li>
        /// </ul>
        ///
        /// <p>If you want to save transcoded files and playlists in one bucket and thumbnails in
        /// another bucket, specify which users can access the transcoded files or the permissions
        /// the users have, or change the Amazon S3 storage class, omit <code>OutputBucket</code>
        /// and specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>
        /// instead.</p>
        pub fn output_bucket(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.output_bucket(inp);
            self
        }
        /// <p>The Amazon S3 bucket in which you want Elastic Transcoder to save the transcoded files. (Use
        /// this, or use ContentConfig:Bucket plus ThumbnailConfig:Bucket.)</p>
        /// <p>Specify this value when all of the following are true:</p>
        /// <ul>
        /// <li>
        /// <p>You want to save transcoded files, thumbnails (if any), and playlists (if any)
        /// together in one bucket.</p>
        /// </li>
        /// <li>
        /// <p>You do not want to specify the users or groups who have access to the transcoded
        /// files, thumbnails, and playlists.</p>
        /// </li>
        /// <li>
        /// <p>You do not want to specify the permissions that Elastic Transcoder grants to the   
        ///
        /// files. </p>
        /// <important>
        /// <p>When Elastic Transcoder saves files in
        /// <code>OutputBucket</code>, it grants full control over the files only to
        /// the AWS account that owns the role that is specified by
        /// <code>Role</code>.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>You want to associate the transcoded files and thumbnails with the Amazon S3
        /// Standard storage class.</p>
        /// </li>
        /// </ul>
        ///
        /// <p>If you want to save transcoded files and playlists in one bucket and thumbnails in
        /// another bucket, specify which users can access the transcoded files or the permissions
        /// the users have, or change the Amazon S3 storage class, omit <code>OutputBucket</code>
        /// and specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>
        /// instead.</p>
        pub fn set_output_bucket(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_output_bucket(input);
            self
        }
        /// <p>The IAM Amazon Resource Name (ARN) for the role that you want Elastic Transcoder to use to create the pipeline.</p>
        pub fn role(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.role(inp);
            self
        }
        /// <p>The IAM Amazon Resource Name (ARN) for the role that you want Elastic Transcoder to use to create the pipeline.</p>
        pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_role(input);
            self
        }
        /// <p>The AWS Key Management Service (AWS KMS) key that you want to use with this pipeline.</p>
        /// <p>If you use either <code>s3</code> or <code>s3-aws-kms</code> as your
        /// <code>Encryption:Mode</code>, you don't need to provide a key with
        /// your job because a default key, known as an AWS-KMS key, is created for you automatically.
        /// You need to provide an AWS-KMS key only if you want to use a non-default AWS-KMS key, or if you are
        /// using an <code>Encryption:Mode</code> of <code>aes-cbc-pkcs7</code>, <code>aes-ctr</code>,
        /// or <code>aes-gcm</code>.</p>
        pub fn aws_kms_key_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.aws_kms_key_arn(inp);
            self
        }
        /// <p>The AWS Key Management Service (AWS KMS) key that you want to use with this pipeline.</p>
        /// <p>If you use either <code>s3</code> or <code>s3-aws-kms</code> as your
        /// <code>Encryption:Mode</code>, you don't need to provide a key with
        /// your job because a default key, known as an AWS-KMS key, is created for you automatically.
        /// You need to provide an AWS-KMS key only if you want to use a non-default AWS-KMS key, or if you are
        /// using an <code>Encryption:Mode</code> of <code>aes-cbc-pkcs7</code>, <code>aes-ctr</code>,
        /// or <code>aes-gcm</code>.</p>
        pub fn set_aws_kms_key_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_aws_kms_key_arn(input);
            self
        }
        /// <p>The Amazon Simple Notification Service (Amazon SNS) topic that you want to notify to report job status.</p>
        /// <important>
        /// <p>To receive notifications, you must also subscribe to the new topic in the Amazon SNS console.</p>
        /// </important>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Progressing</b>: The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to
        /// notify when Elastic Transcoder has started to process a job in this pipeline. This is the ARN that
        /// Amazon SNS returned when you created the topic. For more information, see Create a
        /// Topic in the Amazon Simple Notification Service Developer Guide.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Complete</b>: The topic ARN for the Amazon SNS topic that you want to notify when
        /// Elastic Transcoder has finished processing a job in this pipeline. This is the ARN that Amazon SNS
        /// returned when you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Warning</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters a warning condition while processing a job in this pipeline. This is the
        /// ARN that Amazon SNS returned when you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Error</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters an error condition while processing a job in this pipeline. This is the
        /// ARN that Amazon SNS returned when you created the topic.</p>
        /// </li>
        /// </ul>
        pub fn notifications(mut self, inp: crate::model::Notifications) -> Self {
            self.inner = self.inner.notifications(inp);
            self
        }
        /// <p>The Amazon Simple Notification Service (Amazon SNS) topic that you want to notify to report job status.</p>
        /// <important>
        /// <p>To receive notifications, you must also subscribe to the new topic in the Amazon SNS console.</p>
        /// </important>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Progressing</b>: The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to
        /// notify when Elastic Transcoder has started to process a job in this pipeline. This is the ARN that
        /// Amazon SNS returned when you created the topic. For more information, see Create a
        /// Topic in the Amazon Simple Notification Service Developer Guide.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Complete</b>: The topic ARN for the Amazon SNS topic that you want to notify when
        /// Elastic Transcoder has finished processing a job in this pipeline. This is the ARN that Amazon SNS
        /// returned when you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Warning</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters a warning condition while processing a job in this pipeline. This is the
        /// ARN that Amazon SNS returned when you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Error</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters an error condition while processing a job in this pipeline. This is the
        /// ARN that Amazon SNS returned when you created the topic.</p>
        /// </li>
        /// </ul>
        pub fn set_notifications(
            mut self,
            input: std::option::Option<crate::model::Notifications>,
        ) -> Self {
            self.inner = self.inner.set_notifications(input);
            self
        }
        /// <p>The optional <code>ContentConfig</code> object specifies information about the Amazon S3
        /// bucket in which you want Elastic Transcoder to save transcoded files and playlists:
        /// which bucket to use, which users you want to have access to the files, the type of
        /// access you want users to have, and the storage class that you want to assign to the
        /// files.</p>
        /// <p>If you specify values for <code>ContentConfig</code>, you must also specify values for
        /// <code>ThumbnailConfig</code>.</p>
        /// <p>If you specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>,
        /// omit the <code>OutputBucket</code> object.</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Bucket</b>: The Amazon S3 bucket in which you want Elastic Transcoder to save
        /// transcoded files and playlists.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Permissions</b> (Optional): The Permissions object specifies which users you want
        /// to have access to transcoded files and the type of access you want them to have. You
        /// can grant permissions to a maximum of 30 users and/or predefined Amazon S3
        /// groups.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee Type</b>: Specify the type of value that appears in the
        /// <code>Grantee</code> object: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Canonical</b>: The value in the <code>Grantee</code> object is either the
        /// canonical user ID for an AWS account or an origin access identity for an
        /// Amazon CloudFront distribution. For more information about canonical user
        /// IDs, see Access Control List (ACL) Overview in the Amazon Simple Storage
        /// Service Developer Guide. For more information about using CloudFront origin
        /// access identities to require that users use CloudFront URLs instead of
        /// Amazon S3 URLs, see Using an Origin Access Identity to Restrict Access to
        /// Your Amazon S3 Content.</p>
        /// <important>
        /// <p>A canonical user ID is not the same as an
        /// AWS account number.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Email</b>: The value in the <code>Grantee</code> object is the registered
        /// email address of an AWS account.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Group</b>: The value in the <code>Grantee</code> object is one of the
        /// following predefined Amazon S3 groups: <code>AllUsers</code>,
        /// <code>AuthenticatedUsers</code>, or <code>LogDelivery</code>.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee</b>: The AWS user or group that you want to have access to transcoded
        /// files and playlists. To identify the user or group, you can specify the canonical
        /// user ID for an AWS account, an origin access identity for a CloudFront distribution,
        /// the registered email address of an AWS account, or a predefined Amazon S3 group </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Access</b>: The permission that you want to give to the AWS user that you
        /// specified in <code>Grantee</code>. Permissions are granted on the files that Elastic
        /// Transcoder adds to the bucket, including playlists and video files. Valid values
        /// include: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>READ</code>: The grantee can read the objects and metadata for objects
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>READ_ACP</code>: The grantee can read the object ACL for objects that
        /// Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>WRITE_ACP</code>: The grantee can write the ACL for the objects that
        /// Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FULL_CONTROL</code>: The grantee has <code>READ</code>,
        /// <code>READ_ACP</code>, and <code>WRITE_ACP</code> permissions for the
        /// objects that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>StorageClass</b>: The Amazon S3 storage class, <code>Standard</code> or
        /// <code>ReducedRedundancy</code>, that you want Elastic Transcoder to assign to
        /// the video files and playlists that it stores in your Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        pub fn content_config(mut self, inp: crate::model::PipelineOutputConfig) -> Self {
            self.inner = self.inner.content_config(inp);
            self
        }
        /// <p>The optional <code>ContentConfig</code> object specifies information about the Amazon S3
        /// bucket in which you want Elastic Transcoder to save transcoded files and playlists:
        /// which bucket to use, which users you want to have access to the files, the type of
        /// access you want users to have, and the storage class that you want to assign to the
        /// files.</p>
        /// <p>If you specify values for <code>ContentConfig</code>, you must also specify values for
        /// <code>ThumbnailConfig</code>.</p>
        /// <p>If you specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>,
        /// omit the <code>OutputBucket</code> object.</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Bucket</b>: The Amazon S3 bucket in which you want Elastic Transcoder to save
        /// transcoded files and playlists.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Permissions</b> (Optional): The Permissions object specifies which users you want
        /// to have access to transcoded files and the type of access you want them to have. You
        /// can grant permissions to a maximum of 30 users and/or predefined Amazon S3
        /// groups.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee Type</b>: Specify the type of value that appears in the
        /// <code>Grantee</code> object: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Canonical</b>: The value in the <code>Grantee</code> object is either the
        /// canonical user ID for an AWS account or an origin access identity for an
        /// Amazon CloudFront distribution. For more information about canonical user
        /// IDs, see Access Control List (ACL) Overview in the Amazon Simple Storage
        /// Service Developer Guide. For more information about using CloudFront origin
        /// access identities to require that users use CloudFront URLs instead of
        /// Amazon S3 URLs, see Using an Origin Access Identity to Restrict Access to
        /// Your Amazon S3 Content.</p>
        /// <important>
        /// <p>A canonical user ID is not the same as an
        /// AWS account number.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Email</b>: The value in the <code>Grantee</code> object is the registered
        /// email address of an AWS account.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Group</b>: The value in the <code>Grantee</code> object is one of the
        /// following predefined Amazon S3 groups: <code>AllUsers</code>,
        /// <code>AuthenticatedUsers</code>, or <code>LogDelivery</code>.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee</b>: The AWS user or group that you want to have access to transcoded
        /// files and playlists. To identify the user or group, you can specify the canonical
        /// user ID for an AWS account, an origin access identity for a CloudFront distribution,
        /// the registered email address of an AWS account, or a predefined Amazon S3 group </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Access</b>: The permission that you want to give to the AWS user that you
        /// specified in <code>Grantee</code>. Permissions are granted on the files that Elastic
        /// Transcoder adds to the bucket, including playlists and video files. Valid values
        /// include: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>READ</code>: The grantee can read the objects and metadata for objects
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>READ_ACP</code>: The grantee can read the object ACL for objects that
        /// Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>WRITE_ACP</code>: The grantee can write the ACL for the objects that
        /// Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FULL_CONTROL</code>: The grantee has <code>READ</code>,
        /// <code>READ_ACP</code>, and <code>WRITE_ACP</code> permissions for the
        /// objects that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>StorageClass</b>: The Amazon S3 storage class, <code>Standard</code> or
        /// <code>ReducedRedundancy</code>, that you want Elastic Transcoder to assign to
        /// the video files and playlists that it stores in your Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        pub fn set_content_config(
            mut self,
            input: std::option::Option<crate::model::PipelineOutputConfig>,
        ) -> Self {
            self.inner = self.inner.set_content_config(input);
            self
        }
        /// <p>The <code>ThumbnailConfig</code> object specifies several values, including the Amazon S3
        /// bucket in which you want Elastic Transcoder to save thumbnail files, which users you want to have
        /// access to the files, the type of access you want users to have, and the storage class
        /// that you want to assign to the files.</p>
        /// <p>If you specify values for <code>ContentConfig</code>, you must also specify values for
        /// <code>ThumbnailConfig</code> even if you don't want to create thumbnails.</p>
        /// <p>If you specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>,
        /// omit the <code>OutputBucket</code> object.</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Bucket</b>: The Amazon S3 bucket in which you want Elastic Transcoder to save
        /// thumbnail files.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Permissions</b> (Optional): The <code>Permissions</code> object specifies which
        /// users and/or predefined Amazon S3 groups you want to have access to thumbnail files,
        /// and the type of access you want them to have. You can grant permissions to a maximum
        /// of 30 users and/or predefined Amazon S3 groups.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>GranteeType</b>: Specify the type of value that appears in the Grantee object: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Canonical</b>: The value in the <code>Grantee</code> object is either the
        /// canonical user ID for an AWS account or an origin access identity for an
        /// Amazon CloudFront distribution.</p>
        /// <important>
        /// <p>A canonical user ID is not the
        /// same as an AWS account number.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Email</b>: The value in the <code>Grantee</code> object is the registered
        /// email address of an AWS account. </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Group</b>: The value in the <code>Grantee</code> object is one of the
        /// following predefined Amazon S3 groups: <code>AllUsers</code>,
        /// <code>AuthenticatedUsers</code>, or <code>LogDelivery</code>.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee</b>: The AWS user or group that you want to have access to thumbnail
        /// files. To identify the user or group, you can specify the canonical user ID for an
        /// AWS account, an origin access identity for a CloudFront distribution, the registered
        /// email address of an AWS account, or a predefined Amazon S3 group. </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Access</b>: The permission that you want to give to the AWS user that you
        /// specified in <code>Grantee</code>. Permissions are granted on the thumbnail files
        /// that Elastic Transcoder adds to the bucket. Valid values include: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>READ</code>: The grantee can read the thumbnails and metadata for
        /// objects that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>READ_ACP</code>: The grantee can read the object ACL for thumbnails
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>WRITE_ACP</code>: The grantee can write the ACL for the thumbnails
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FULL_CONTROL</code>: The grantee has <code>READ</code>,
        /// <code>READ_ACP</code>, and <code>WRITE_ACP</code> permissions for the
        /// thumbnails that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>StorageClass</b>: The Amazon S3 storage class, <code>Standard</code> or
        /// <code>ReducedRedundancy</code>, that you want Elastic Transcoder to assign to
        /// the thumbnails that it stores in your Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        pub fn thumbnail_config(mut self, inp: crate::model::PipelineOutputConfig) -> Self {
            self.inner = self.inner.thumbnail_config(inp);
            self
        }
        /// <p>The <code>ThumbnailConfig</code> object specifies several values, including the Amazon S3
        /// bucket in which you want Elastic Transcoder to save thumbnail files, which users you want to have
        /// access to the files, the type of access you want users to have, and the storage class
        /// that you want to assign to the files.</p>
        /// <p>If you specify values for <code>ContentConfig</code>, you must also specify values for
        /// <code>ThumbnailConfig</code> even if you don't want to create thumbnails.</p>
        /// <p>If you specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>,
        /// omit the <code>OutputBucket</code> object.</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Bucket</b>: The Amazon S3 bucket in which you want Elastic Transcoder to save
        /// thumbnail files.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Permissions</b> (Optional): The <code>Permissions</code> object specifies which
        /// users and/or predefined Amazon S3 groups you want to have access to thumbnail files,
        /// and the type of access you want them to have. You can grant permissions to a maximum
        /// of 30 users and/or predefined Amazon S3 groups.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>GranteeType</b>: Specify the type of value that appears in the Grantee object: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Canonical</b>: The value in the <code>Grantee</code> object is either the
        /// canonical user ID for an AWS account or an origin access identity for an
        /// Amazon CloudFront distribution.</p>
        /// <important>
        /// <p>A canonical user ID is not the
        /// same as an AWS account number.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Email</b>: The value in the <code>Grantee</code> object is the registered
        /// email address of an AWS account. </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Group</b>: The value in the <code>Grantee</code> object is one of the
        /// following predefined Amazon S3 groups: <code>AllUsers</code>,
        /// <code>AuthenticatedUsers</code>, or <code>LogDelivery</code>.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee</b>: The AWS user or group that you want to have access to thumbnail
        /// files. To identify the user or group, you can specify the canonical user ID for an
        /// AWS account, an origin access identity for a CloudFront distribution, the registered
        /// email address of an AWS account, or a predefined Amazon S3 group. </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Access</b>: The permission that you want to give to the AWS user that you
        /// specified in <code>Grantee</code>. Permissions are granted on the thumbnail files
        /// that Elastic Transcoder adds to the bucket. Valid values include: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>READ</code>: The grantee can read the thumbnails and metadata for
        /// objects that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>READ_ACP</code>: The grantee can read the object ACL for thumbnails
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>WRITE_ACP</code>: The grantee can write the ACL for the thumbnails
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FULL_CONTROL</code>: The grantee has <code>READ</code>,
        /// <code>READ_ACP</code>, and <code>WRITE_ACP</code> permissions for the
        /// thumbnails that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>StorageClass</b>: The Amazon S3 storage class, <code>Standard</code> or
        /// <code>ReducedRedundancy</code>, that you want Elastic Transcoder to assign to
        /// the thumbnails that it stores in your Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        pub fn set_thumbnail_config(
            mut self,
            input: std::option::Option<crate::model::PipelineOutputConfig>,
        ) -> Self {
            self.inner = self.inner.set_thumbnail_config(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreatePreset`.
    ///
    /// <p>The CreatePreset operation creates a preset with settings that you specify.</p>
    /// <important>
    /// <p>Elastic Transcoder checks the CreatePreset settings to ensure that they meet Elastic Transcoder requirements
    /// and to determine whether they comply with H.264 standards. If your settings are not
    /// valid for Elastic Transcoder, Elastic Transcoder returns an HTTP 400 response (<code>ValidationException</code>) and
    /// does not create the preset. If the settings are valid for Elastic Transcoder but aren't strictly
    /// compliant with the H.264 standard, Elastic Transcoder creates the preset and returns a warning message
    /// in the response. This helps you determine whether your settings comply with the H.264
    /// standard while giving you greater flexibility with respect to the video that Elastic Transcoder
    /// produces.</p>
    /// </important>
    /// <p>Elastic Transcoder uses the H.264 video-compression format. For more information, see the International
    /// Telecommunication Union publication <i>Recommendation ITU-T H.264: Advanced video coding
    /// for generic audiovisual services</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct CreatePreset<
        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_preset_input::Builder,
    }
    impl<C, M, R> CreatePreset<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 `CreatePreset`.
        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::CreatePresetOutput,
            aws_smithy_http::result::SdkError<crate::error::CreatePresetError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreatePresetInputOperationOutputAlias,
                crate::output::CreatePresetOutput,
                crate::error::CreatePresetError,
                crate::input::CreatePresetInputOperationRetryAlias,
            >,
        {
            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 preset. We recommend that the name be unique within the AWS account, but uniqueness is not enforced.</p>
        pub fn name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(inp);
            self
        }
        /// <p>The name of the preset. We recommend that the name be unique within the AWS account, but uniqueness is not enforced.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>A description of the preset.</p>
        pub fn description(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(inp);
            self
        }
        /// <p>A description of the preset.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
        /// <p>The container type for the output file. Valid values include <code>flac</code>,
        /// <code>flv</code>, <code>fmp4</code>,
        /// <code>gif</code>, <code>mp3</code>,
        /// <code>mp4</code>, <code>mpg</code>, <code>mxf</code>, <code>oga</code>,
        /// <code>ogg</code>, <code>ts</code>, and <code>webm</code>.</p>
        pub fn container(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.container(inp);
            self
        }
        /// <p>The container type for the output file. Valid values include <code>flac</code>,
        /// <code>flv</code>, <code>fmp4</code>,
        /// <code>gif</code>, <code>mp3</code>,
        /// <code>mp4</code>, <code>mpg</code>, <code>mxf</code>, <code>oga</code>,
        /// <code>ogg</code>, <code>ts</code>, and <code>webm</code>.</p>
        pub fn set_container(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_container(input);
            self
        }
        /// <p>A section of the request body that specifies the video parameters.</p>
        pub fn video(mut self, inp: crate::model::VideoParameters) -> Self {
            self.inner = self.inner.video(inp);
            self
        }
        /// <p>A section of the request body that specifies the video parameters.</p>
        pub fn set_video(
            mut self,
            input: std::option::Option<crate::model::VideoParameters>,
        ) -> Self {
            self.inner = self.inner.set_video(input);
            self
        }
        /// <p>A section of the request body that specifies the audio parameters.</p>
        pub fn audio(mut self, inp: crate::model::AudioParameters) -> Self {
            self.inner = self.inner.audio(inp);
            self
        }
        /// <p>A section of the request body that specifies the audio parameters.</p>
        pub fn set_audio(
            mut self,
            input: std::option::Option<crate::model::AudioParameters>,
        ) -> Self {
            self.inner = self.inner.set_audio(input);
            self
        }
        /// <p>A section of the request body that specifies the thumbnail parameters, if any.</p>
        pub fn thumbnails(mut self, inp: crate::model::Thumbnails) -> Self {
            self.inner = self.inner.thumbnails(inp);
            self
        }
        /// <p>A section of the request body that specifies the thumbnail parameters, if any.</p>
        pub fn set_thumbnails(
            mut self,
            input: std::option::Option<crate::model::Thumbnails>,
        ) -> Self {
            self.inner = self.inner.set_thumbnails(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeletePipeline`.
    ///
    /// <p>The DeletePipeline operation removes a pipeline.</p>
    /// <p> You can only delete a pipeline that has never been used or that is not currently in use
    /// (doesn't contain any active jobs). If the pipeline is currently in use,
    /// <code>DeletePipeline</code> returns an error. </p>
    #[derive(std::fmt::Debug)]
    pub struct DeletePipeline<
        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_pipeline_input::Builder,
    }
    impl<C, M, R> DeletePipeline<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 `DeletePipeline`.
        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::DeletePipelineOutput,
            aws_smithy_http::result::SdkError<crate::error::DeletePipelineError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeletePipelineInputOperationOutputAlias,
                crate::output::DeletePipelineOutput,
                crate::error::DeletePipelineError,
                crate::input::DeletePipelineInputOperationRetryAlias,
            >,
        {
            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 identifier of the pipeline that you want to delete.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The identifier of the pipeline that you want to delete.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeletePreset`.
    ///
    /// <p>The DeletePreset operation removes a preset that you've added in an AWS region.</p>
    /// <note>
    /// <p>You can't delete the default presets that are included with Elastic Transcoder.</p>
    /// </note>
    #[derive(std::fmt::Debug)]
    pub struct DeletePreset<
        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_preset_input::Builder,
    }
    impl<C, M, R> DeletePreset<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 `DeletePreset`.
        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::DeletePresetOutput,
            aws_smithy_http::result::SdkError<crate::error::DeletePresetError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeletePresetInputOperationOutputAlias,
                crate::output::DeletePresetOutput,
                crate::error::DeletePresetError,
                crate::input::DeletePresetInputOperationRetryAlias,
            >,
        {
            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 identifier of the preset for which you want to get detailed information.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The identifier of the preset for which you want to get detailed information.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListJobsByPipeline`.
    ///
    /// <p>The ListJobsByPipeline operation gets a list of the jobs currently in a pipeline.</p>
    /// <p>Elastic Transcoder returns all of the jobs currently in the specified pipeline. The response body contains
    /// one element for each job that satisfies the search criteria.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListJobsByPipeline<
        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_by_pipeline_input::Builder,
    }
    impl<C, M, R> ListJobsByPipeline<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 `ListJobsByPipeline`.
        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::ListJobsByPipelineOutput,
            aws_smithy_http::result::SdkError<crate::error::ListJobsByPipelineError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListJobsByPipelineInputOperationOutputAlias,
                crate::output::ListJobsByPipelineOutput,
                crate::error::ListJobsByPipelineError,
                crate::input::ListJobsByPipelineInputOperationRetryAlias,
            >,
        {
            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 ID of the pipeline for which you want to get job information.</p>
        pub fn pipeline_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.pipeline_id(inp);
            self
        }
        /// <p>The ID of the pipeline for which you want to get job information.</p>
        pub fn set_pipeline_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_pipeline_id(input);
            self
        }
        /// <p> To list jobs in chronological order by the date and time that they were submitted, enter
        /// <code>true</code>. To list jobs in reverse chronological order, enter
        /// <code>false</code>. </p>
        pub fn ascending(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.ascending(inp);
            self
        }
        /// <p> To list jobs in chronological order by the date and time that they were submitted, enter
        /// <code>true</code>. To list jobs in reverse chronological order, enter
        /// <code>false</code>. </p>
        pub fn set_ascending(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_ascending(input);
            self
        }
        /// <p> When Elastic Transcoder returns more than one page of results, use <code>pageToken</code> in
        /// subsequent <code>GET</code> requests to get each successive page of results. </p>
        pub fn page_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.page_token(inp);
            self
        }
        /// <p> When Elastic Transcoder returns more than one page of results, use <code>pageToken</code> in
        /// subsequent <code>GET</code> requests to get each successive page of results. </p>
        pub fn set_page_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_page_token(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListJobsByStatus`.
    ///
    /// <p>The ListJobsByStatus operation gets a list of jobs that have a specified status. The response
    /// body contains one element for each job that satisfies the search criteria.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListJobsByStatus<
        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_by_status_input::Builder,
    }
    impl<C, M, R> ListJobsByStatus<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 `ListJobsByStatus`.
        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::ListJobsByStatusOutput,
            aws_smithy_http::result::SdkError<crate::error::ListJobsByStatusError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListJobsByStatusInputOperationOutputAlias,
                crate::output::ListJobsByStatusOutput,
                crate::error::ListJobsByStatusError,
                crate::input::ListJobsByStatusInputOperationRetryAlias,
            >,
        {
            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>To get information about all of the jobs associated with the current AWS account that
        /// have a given status, specify the following status: <code>Submitted</code>,
        /// <code>Progressing</code>, <code>Complete</code>, <code>Canceled</code>, or
        /// <code>Error</code>.</p>
        pub fn status(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.status(inp);
            self
        }
        /// <p>To get information about all of the jobs associated with the current AWS account that
        /// have a given status, specify the following status: <code>Submitted</code>,
        /// <code>Progressing</code>, <code>Complete</code>, <code>Canceled</code>, or
        /// <code>Error</code>.</p>
        pub fn set_status(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_status(input);
            self
        }
        /// <p> To list jobs in chronological order by the date and time that they were submitted, enter
        /// <code>true</code>. To list jobs in reverse chronological order, enter
        /// <code>false</code>. </p>
        pub fn ascending(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.ascending(inp);
            self
        }
        /// <p> To list jobs in chronological order by the date and time that they were submitted, enter
        /// <code>true</code>. To list jobs in reverse chronological order, enter
        /// <code>false</code>. </p>
        pub fn set_ascending(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_ascending(input);
            self
        }
        /// <p> When Elastic Transcoder returns more than one page of results, use <code>pageToken</code> in
        /// subsequent <code>GET</code> requests to get each successive page of results. </p>
        pub fn page_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.page_token(inp);
            self
        }
        /// <p> When Elastic Transcoder returns more than one page of results, use <code>pageToken</code> in
        /// subsequent <code>GET</code> requests to get each successive page of results. </p>
        pub fn set_page_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_page_token(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListPipelines`.
    ///
    /// <p>The ListPipelines operation gets a list of the pipelines associated with the current AWS account.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListPipelines<
        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_pipelines_input::Builder,
    }
    impl<C, M, R> ListPipelines<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 `ListPipelines`.
        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::ListPipelinesOutput,
            aws_smithy_http::result::SdkError<crate::error::ListPipelinesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListPipelinesInputOperationOutputAlias,
                crate::output::ListPipelinesOutput,
                crate::error::ListPipelinesError,
                crate::input::ListPipelinesInputOperationRetryAlias,
            >,
        {
            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>To list pipelines in chronological order by the date and time that they were created, enter
        /// <code>true</code>. To list pipelines in reverse chronological order, enter
        /// <code>false</code>.</p>
        pub fn ascending(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.ascending(inp);
            self
        }
        /// <p>To list pipelines in chronological order by the date and time that they were created, enter
        /// <code>true</code>. To list pipelines in reverse chronological order, enter
        /// <code>false</code>.</p>
        pub fn set_ascending(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_ascending(input);
            self
        }
        /// <p>When Elastic Transcoder returns more than one page of results, use <code>pageToken</code> in
        /// subsequent <code>GET</code> requests to get each successive page of results. </p>
        pub fn page_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.page_token(inp);
            self
        }
        /// <p>When Elastic Transcoder returns more than one page of results, use <code>pageToken</code> in
        /// subsequent <code>GET</code> requests to get each successive page of results. </p>
        pub fn set_page_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_page_token(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListPresets`.
    ///
    /// <p>The ListPresets operation gets a list of the default presets included with Elastic Transcoder and the presets that
    /// you've added in an AWS region.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListPresets<
        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_presets_input::Builder,
    }
    impl<C, M, R> ListPresets<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 `ListPresets`.
        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::ListPresetsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListPresetsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListPresetsInputOperationOutputAlias,
                crate::output::ListPresetsOutput,
                crate::error::ListPresetsError,
                crate::input::ListPresetsInputOperationRetryAlias,
            >,
        {
            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>To list presets in chronological order by the date and time that they were created, enter
        /// <code>true</code>. To list presets in reverse chronological order, enter
        /// <code>false</code>.</p>
        pub fn ascending(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.ascending(inp);
            self
        }
        /// <p>To list presets in chronological order by the date and time that they were created, enter
        /// <code>true</code>. To list presets in reverse chronological order, enter
        /// <code>false</code>.</p>
        pub fn set_ascending(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_ascending(input);
            self
        }
        /// <p>When Elastic Transcoder returns more than one page of results, use <code>pageToken</code> in
        /// subsequent <code>GET</code> requests to get each successive page of results. </p>
        pub fn page_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.page_token(inp);
            self
        }
        /// <p>When Elastic Transcoder returns more than one page of results, use <code>pageToken</code> in
        /// subsequent <code>GET</code> requests to get each successive page of results. </p>
        pub fn set_page_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_page_token(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ReadJob`.
    ///
    /// <p>The ReadJob operation returns detailed information about a job.</p>
    #[derive(std::fmt::Debug)]
    pub struct ReadJob<
        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::read_job_input::Builder,
    }
    impl<C, M, R> ReadJob<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 `ReadJob`.
        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::ReadJobOutput,
            aws_smithy_http::result::SdkError<crate::error::ReadJobError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ReadJobInputOperationOutputAlias,
                crate::output::ReadJobOutput,
                crate::error::ReadJobError,
                crate::input::ReadJobInputOperationRetryAlias,
            >,
        {
            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 identifier of the job for which you want to get detailed information.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The identifier of the job for which you want to get detailed information.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ReadPipeline`.
    ///
    /// <p>The ReadPipeline operation gets detailed information about a pipeline.</p>
    #[derive(std::fmt::Debug)]
    pub struct ReadPipeline<
        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::read_pipeline_input::Builder,
    }
    impl<C, M, R> ReadPipeline<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 `ReadPipeline`.
        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::ReadPipelineOutput,
            aws_smithy_http::result::SdkError<crate::error::ReadPipelineError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ReadPipelineInputOperationOutputAlias,
                crate::output::ReadPipelineOutput,
                crate::error::ReadPipelineError,
                crate::input::ReadPipelineInputOperationRetryAlias,
            >,
        {
            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 identifier of the pipeline to read.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The identifier of the pipeline to read.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ReadPreset`.
    ///
    /// <p>The ReadPreset operation gets detailed information about a preset.</p>
    #[derive(std::fmt::Debug)]
    pub struct ReadPreset<
        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::read_preset_input::Builder,
    }
    impl<C, M, R> ReadPreset<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 `ReadPreset`.
        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::ReadPresetOutput,
            aws_smithy_http::result::SdkError<crate::error::ReadPresetError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ReadPresetInputOperationOutputAlias,
                crate::output::ReadPresetOutput,
                crate::error::ReadPresetError,
                crate::input::ReadPresetInputOperationRetryAlias,
            >,
        {
            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 identifier of the preset for which you want to get detailed information.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The identifier of the preset for which you want to get detailed information.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `TestRole`.
    ///
    /// <p>The TestRole operation tests the IAM role used to create the pipeline.</p>
    /// <p>The <code>TestRole</code> action lets you determine whether the IAM role you are using
    /// has sufficient permissions to let Elastic Transcoder perform tasks associated with the transcoding
    /// process. The action attempts to assume the specified IAM role, checks read access to the
    /// input and output buckets, and tries to send a test notification to Amazon SNS topics
    /// that you specify.</p>
    #[derive(std::fmt::Debug)]
    pub struct TestRole<
        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::test_role_input::Builder,
    }
    impl<C, M, R> TestRole<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 `TestRole`.
        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::TestRoleOutput,
            aws_smithy_http::result::SdkError<crate::error::TestRoleError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::TestRoleInputOperationOutputAlias,
                crate::output::TestRoleOutput,
                crate::error::TestRoleError,
                crate::input::TestRoleInputOperationRetryAlias,
            >,
        {
            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 IAM Amazon Resource Name (ARN) for the role that you want Elastic Transcoder to test.</p>
        pub fn role(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.role(inp);
            self
        }
        /// <p>The IAM Amazon Resource Name (ARN) for the role that you want Elastic Transcoder to test.</p>
        pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_role(input);
            self
        }
        /// <p>The Amazon S3 bucket that contains media files to be transcoded. The action attempts to read from this bucket.</p>
        pub fn input_bucket(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.input_bucket(inp);
            self
        }
        /// <p>The Amazon S3 bucket that contains media files to be transcoded. The action attempts to read from this bucket.</p>
        pub fn set_input_bucket(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_input_bucket(input);
            self
        }
        /// <p>The Amazon S3 bucket that Elastic Transcoder writes transcoded media files to. The action attempts to read from this bucket.</p>
        pub fn output_bucket(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.output_bucket(inp);
            self
        }
        /// <p>The Amazon S3 bucket that Elastic Transcoder writes transcoded media files to. The action attempts to read from this bucket.</p>
        pub fn set_output_bucket(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_output_bucket(input);
            self
        }
        /// Appends an item to `Topics`.
        ///
        /// To override the contents of this collection use [`set_topics`](Self::set_topics).
        ///
        /// <p>The ARNs of one or more Amazon Simple Notification Service (Amazon SNS) topics that you want the action to send a test notification to.</p>
        pub fn topics(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topics(inp);
            self
        }
        /// <p>The ARNs of one or more Amazon Simple Notification Service (Amazon SNS) topics that you want the action to send a test notification to.</p>
        pub fn set_topics(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_topics(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdatePipeline`.
    ///
    /// <p> Use the <code>UpdatePipeline</code> operation to update settings for a pipeline.</p>
    /// <important>
    /// <p>When you change pipeline settings, your changes take effect immediately.
    /// Jobs that you have already submitted and that Elastic Transcoder has not started to process are
    /// affected in addition to jobs that you submit after you change settings. </p>
    /// </important>
    #[derive(std::fmt::Debug)]
    pub struct UpdatePipeline<
        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_pipeline_input::Builder,
    }
    impl<C, M, R> UpdatePipeline<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 `UpdatePipeline`.
        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::UpdatePipelineOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdatePipelineError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UpdatePipelineInputOperationOutputAlias,
                crate::output::UpdatePipelineOutput,
                crate::error::UpdatePipelineError,
                crate::input::UpdatePipelineInputOperationRetryAlias,
            >,
        {
            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 ID of the pipeline that you want to update.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The ID of the pipeline that you want to update.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
        /// <p>The name of the pipeline. We recommend that the name be unique within the AWS account, but
        /// uniqueness is not enforced.</p>
        /// <p>Constraints: Maximum 40 characters</p>
        pub fn name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(inp);
            self
        }
        /// <p>The name of the pipeline. We recommend that the name be unique within the AWS account, but
        /// uniqueness is not enforced.</p>
        /// <p>Constraints: Maximum 40 characters</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>The Amazon S3 bucket in which you saved the media files that you want to transcode and the graphics
        /// that you want to use as watermarks.</p>
        pub fn input_bucket(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.input_bucket(inp);
            self
        }
        /// <p>The Amazon S3 bucket in which you saved the media files that you want to transcode and the graphics
        /// that you want to use as watermarks.</p>
        pub fn set_input_bucket(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_input_bucket(input);
            self
        }
        /// <p>The IAM Amazon Resource Name (ARN) for the role that you want Elastic Transcoder to use to transcode jobs for
        /// this pipeline.</p>
        pub fn role(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.role(inp);
            self
        }
        /// <p>The IAM Amazon Resource Name (ARN) for the role that you want Elastic Transcoder to use to transcode jobs for
        /// this pipeline.</p>
        pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_role(input);
            self
        }
        /// <p>The AWS Key Management Service (AWS KMS) key that you want to use with this pipeline.</p>
        /// <p>If you use either <code>s3</code> or <code>s3-aws-kms</code> as your <code>Encryption:Mode</code>,
        /// you don't need to provide a key with your job because a default key, known as an AWS-KMS key, is
        /// created for you automatically. You need to provide an AWS-KMS key only if you want to use a non-default
        /// AWS-KMS key, or if you are using an <code>Encryption:Mode</code> of <code>aes-cbc-pkcs7</code>, <code>aes-ctr</code>,
        /// or <code>aes-gcm</code>.</p>
        pub fn aws_kms_key_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.aws_kms_key_arn(inp);
            self
        }
        /// <p>The AWS Key Management Service (AWS KMS) key that you want to use with this pipeline.</p>
        /// <p>If you use either <code>s3</code> or <code>s3-aws-kms</code> as your <code>Encryption:Mode</code>,
        /// you don't need to provide a key with your job because a default key, known as an AWS-KMS key, is
        /// created for you automatically. You need to provide an AWS-KMS key only if you want to use a non-default
        /// AWS-KMS key, or if you are using an <code>Encryption:Mode</code> of <code>aes-cbc-pkcs7</code>, <code>aes-ctr</code>,
        /// or <code>aes-gcm</code>.</p>
        pub fn set_aws_kms_key_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_aws_kms_key_arn(input);
            self
        }
        /// <p>The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to notify to report job status.</p>
        /// <important>
        /// <p>To receive notifications, you must also subscribe to the new topic in the Amazon SNS console.</p>
        /// </important>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Progressing</b>: The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to
        /// notify when Elastic Transcoder has started to process jobs that are added to this pipeline. This
        /// is the ARN that Amazon SNS returned when you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Complete</b>: The topic ARN for the Amazon SNS topic that you want to notify when
        /// Elastic Transcoder has finished processing a job. This is the ARN that Amazon SNS returned when
        /// you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Warning</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters a warning condition. This is the ARN that Amazon SNS returned when you
        /// created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Error</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters an error condition. This is the ARN that Amazon SNS returned when you
        /// created the topic.</p>
        /// </li>
        /// </ul>
        pub fn notifications(mut self, inp: crate::model::Notifications) -> Self {
            self.inner = self.inner.notifications(inp);
            self
        }
        /// <p>The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to notify to report job status.</p>
        /// <important>
        /// <p>To receive notifications, you must also subscribe to the new topic in the Amazon SNS console.</p>
        /// </important>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Progressing</b>: The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to
        /// notify when Elastic Transcoder has started to process jobs that are added to this pipeline. This
        /// is the ARN that Amazon SNS returned when you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Complete</b>: The topic ARN for the Amazon SNS topic that you want to notify when
        /// Elastic Transcoder has finished processing a job. This is the ARN that Amazon SNS returned when
        /// you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Warning</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters a warning condition. This is the ARN that Amazon SNS returned when you
        /// created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Error</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters an error condition. This is the ARN that Amazon SNS returned when you
        /// created the topic.</p>
        /// </li>
        /// </ul>
        pub fn set_notifications(
            mut self,
            input: std::option::Option<crate::model::Notifications>,
        ) -> Self {
            self.inner = self.inner.set_notifications(input);
            self
        }
        /// <p>The optional <code>ContentConfig</code> object specifies information about the Amazon S3
        /// bucket in which you want Elastic Transcoder to save transcoded files and playlists:
        /// which bucket to use, which users you want to have access to the files, the type of
        /// access you want users to have, and the storage class that you want to assign to the
        /// files.</p>
        /// <p>If you specify values for <code>ContentConfig</code>, you must also specify values for
        /// <code>ThumbnailConfig</code>.</p>
        /// <p>If you specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>,
        /// omit the <code>OutputBucket</code> object.</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Bucket</b>: The Amazon S3 bucket in which you want Elastic Transcoder to save
        /// transcoded files and playlists.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Permissions</b> (Optional): The Permissions object specifies which users you want
        /// to have access to transcoded files and the type of access you want them to have. You
        /// can grant permissions to a maximum of 30 users and/or predefined Amazon S3
        /// groups.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee Type</b>: Specify the type of value that appears in the
        /// <code>Grantee</code> object:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Canonical</b>: The value in the <code>Grantee</code> object is either the
        /// canonical user ID for an AWS account or an origin access identity for an
        /// Amazon CloudFront distribution. For more information about canonical user
        /// IDs, see Access Control List (ACL) Overview in the Amazon Simple Storage
        /// Service Developer Guide. For more information about using CloudFront origin
        /// access identities to require that users use CloudFront URLs instead of
        /// Amazon S3 URLs, see Using an Origin Access Identity to Restrict Access to
        /// Your Amazon S3 Content.</p>
        /// <important>
        /// <p>A canonical user ID is not the same as an
        /// AWS account number.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Email</b>: The value in the <code>Grantee</code> object is the registered
        /// email address of an AWS account.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Group</b>: The value in the <code>Grantee</code> object is one of the
        /// following predefined Amazon S3 groups: <code>AllUsers</code>,
        /// <code>AuthenticatedUsers</code>, or <code>LogDelivery</code>.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee</b>: The AWS user or group that you want to have access to transcoded
        /// files and playlists. To identify the user or group, you can specify the canonical
        /// user ID for an AWS account, an origin access identity for a CloudFront distribution,
        /// the registered email address of an AWS account, or a predefined Amazon S3 group </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Access</b>: The permission that you want to give to the AWS user that you
        /// specified in <code>Grantee</code>. Permissions are granted on the files that Elastic
        /// Transcoder adds to the bucket, including playlists and video files. Valid values
        /// include: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>READ</code>: The grantee can read the objects and metadata for objects
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>READ_ACP</code>: The grantee can read the object ACL for objects that
        /// Elastic Transcoder adds to the Amazon S3 bucket. </p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>WRITE_ACP</code>: The grantee can write the ACL for the objects that
        /// Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FULL_CONTROL</code>: The grantee has <code>READ</code>,
        /// <code>READ_ACP</code>, and <code>WRITE_ACP</code> permissions for the
        /// objects that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>StorageClass</b>: The Amazon S3 storage class, <code>Standard</code> or
        /// <code>ReducedRedundancy</code>, that you want Elastic Transcoder to assign to
        /// the video files and playlists that it stores in your Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        pub fn content_config(mut self, inp: crate::model::PipelineOutputConfig) -> Self {
            self.inner = self.inner.content_config(inp);
            self
        }
        /// <p>The optional <code>ContentConfig</code> object specifies information about the Amazon S3
        /// bucket in which you want Elastic Transcoder to save transcoded files and playlists:
        /// which bucket to use, which users you want to have access to the files, the type of
        /// access you want users to have, and the storage class that you want to assign to the
        /// files.</p>
        /// <p>If you specify values for <code>ContentConfig</code>, you must also specify values for
        /// <code>ThumbnailConfig</code>.</p>
        /// <p>If you specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>,
        /// omit the <code>OutputBucket</code> object.</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Bucket</b>: The Amazon S3 bucket in which you want Elastic Transcoder to save
        /// transcoded files and playlists.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Permissions</b> (Optional): The Permissions object specifies which users you want
        /// to have access to transcoded files and the type of access you want them to have. You
        /// can grant permissions to a maximum of 30 users and/or predefined Amazon S3
        /// groups.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee Type</b>: Specify the type of value that appears in the
        /// <code>Grantee</code> object:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Canonical</b>: The value in the <code>Grantee</code> object is either the
        /// canonical user ID for an AWS account or an origin access identity for an
        /// Amazon CloudFront distribution. For more information about canonical user
        /// IDs, see Access Control List (ACL) Overview in the Amazon Simple Storage
        /// Service Developer Guide. For more information about using CloudFront origin
        /// access identities to require that users use CloudFront URLs instead of
        /// Amazon S3 URLs, see Using an Origin Access Identity to Restrict Access to
        /// Your Amazon S3 Content.</p>
        /// <important>
        /// <p>A canonical user ID is not the same as an
        /// AWS account number.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Email</b>: The value in the <code>Grantee</code> object is the registered
        /// email address of an AWS account.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Group</b>: The value in the <code>Grantee</code> object is one of the
        /// following predefined Amazon S3 groups: <code>AllUsers</code>,
        /// <code>AuthenticatedUsers</code>, or <code>LogDelivery</code>.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee</b>: The AWS user or group that you want to have access to transcoded
        /// files and playlists. To identify the user or group, you can specify the canonical
        /// user ID for an AWS account, an origin access identity for a CloudFront distribution,
        /// the registered email address of an AWS account, or a predefined Amazon S3 group </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Access</b>: The permission that you want to give to the AWS user that you
        /// specified in <code>Grantee</code>. Permissions are granted on the files that Elastic
        /// Transcoder adds to the bucket, including playlists and video files. Valid values
        /// include: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>READ</code>: The grantee can read the objects and metadata for objects
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>READ_ACP</code>: The grantee can read the object ACL for objects that
        /// Elastic Transcoder adds to the Amazon S3 bucket. </p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>WRITE_ACP</code>: The grantee can write the ACL for the objects that
        /// Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FULL_CONTROL</code>: The grantee has <code>READ</code>,
        /// <code>READ_ACP</code>, and <code>WRITE_ACP</code> permissions for the
        /// objects that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>StorageClass</b>: The Amazon S3 storage class, <code>Standard</code> or
        /// <code>ReducedRedundancy</code>, that you want Elastic Transcoder to assign to
        /// the video files and playlists that it stores in your Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        pub fn set_content_config(
            mut self,
            input: std::option::Option<crate::model::PipelineOutputConfig>,
        ) -> Self {
            self.inner = self.inner.set_content_config(input);
            self
        }
        /// <p>The <code>ThumbnailConfig</code> object specifies several values, including the Amazon S3
        /// bucket in which you want Elastic Transcoder to save thumbnail files, which users you want to have
        /// access to the files, the type of access you want users to have, and the storage class
        /// that you want to assign to the files.</p>
        /// <p>If you specify values for <code>ContentConfig</code>, you must also specify values for
        /// <code>ThumbnailConfig</code> even if you don't want to create thumbnails.</p>
        /// <p>If you specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>,
        /// omit the <code>OutputBucket</code> object.</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Bucket</b>: The Amazon S3 bucket in which you want Elastic Transcoder to save
        /// thumbnail files.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Permissions</b> (Optional): The <code>Permissions</code> object specifies which
        /// users and/or predefined Amazon S3 groups you want to have access to thumbnail files,
        /// and the type of access you want them to have. You can grant permissions to a maximum
        /// of 30 users and/or predefined Amazon S3 groups.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>GranteeType</b>: Specify the type of value that appears in the Grantee object:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Canonical</b>: The value in the <code>Grantee</code> object is either the
        /// canonical user ID for an AWS account or an origin access identity for an
        /// Amazon CloudFront distribution.</p>
        /// <important>
        /// <p>A canonical user ID is not the
        /// same as an AWS account number.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Email</b>: The value in the <code>Grantee</code> object is the registered
        /// email address of an AWS account.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Group</b>: The value in the <code>Grantee</code> object is one of the
        /// following predefined Amazon S3 groups: <code>AllUsers</code>,
        /// <code>AuthenticatedUsers</code>, or <code>LogDelivery</code>.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee</b>: The AWS user or group that you want to have access to thumbnail
        /// files. To identify the user or group, you can specify the canonical user ID for an
        /// AWS account, an origin access identity for a CloudFront distribution, the registered
        /// email address of an AWS account, or a predefined Amazon S3 group. </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Access</b>: The permission that you want to give to the AWS user that you
        /// specified in <code>Grantee</code>. Permissions are granted on the thumbnail files
        /// that Elastic Transcoder adds to the bucket. Valid values include: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>READ</code>: The grantee can read the thumbnails and metadata for
        /// objects that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>READ_ACP</code>: The grantee can read the object ACL for thumbnails
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>WRITE_ACP</code>: The grantee can write the ACL for the thumbnails
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FULL_CONTROL</code>: The grantee has <code>READ</code>,
        /// <code>READ_ACP</code>, and <code>WRITE_ACP</code> permissions for the
        /// thumbnails that Elastic Transcoder adds to the Amazon S3 bucket. </p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>StorageClass</b>: The Amazon S3 storage class, <code>Standard</code> or
        /// <code>ReducedRedundancy</code>, that you want Elastic Transcoder to assign to
        /// the thumbnails that it stores in your Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        pub fn thumbnail_config(mut self, inp: crate::model::PipelineOutputConfig) -> Self {
            self.inner = self.inner.thumbnail_config(inp);
            self
        }
        /// <p>The <code>ThumbnailConfig</code> object specifies several values, including the Amazon S3
        /// bucket in which you want Elastic Transcoder to save thumbnail files, which users you want to have
        /// access to the files, the type of access you want users to have, and the storage class
        /// that you want to assign to the files.</p>
        /// <p>If you specify values for <code>ContentConfig</code>, you must also specify values for
        /// <code>ThumbnailConfig</code> even if you don't want to create thumbnails.</p>
        /// <p>If you specify values for <code>ContentConfig</code> and <code>ThumbnailConfig</code>,
        /// omit the <code>OutputBucket</code> object.</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Bucket</b>: The Amazon S3 bucket in which you want Elastic Transcoder to save
        /// thumbnail files.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Permissions</b> (Optional): The <code>Permissions</code> object specifies which
        /// users and/or predefined Amazon S3 groups you want to have access to thumbnail files,
        /// and the type of access you want them to have. You can grant permissions to a maximum
        /// of 30 users and/or predefined Amazon S3 groups.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>GranteeType</b>: Specify the type of value that appears in the Grantee object:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Canonical</b>: The value in the <code>Grantee</code> object is either the
        /// canonical user ID for an AWS account or an origin access identity for an
        /// Amazon CloudFront distribution.</p>
        /// <important>
        /// <p>A canonical user ID is not the
        /// same as an AWS account number.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Email</b>: The value in the <code>Grantee</code> object is the registered
        /// email address of an AWS account.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Group</b>: The value in the <code>Grantee</code> object is one of the
        /// following predefined Amazon S3 groups: <code>AllUsers</code>,
        /// <code>AuthenticatedUsers</code>, or <code>LogDelivery</code>.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Grantee</b>: The AWS user or group that you want to have access to thumbnail
        /// files. To identify the user or group, you can specify the canonical user ID for an
        /// AWS account, an origin access identity for a CloudFront distribution, the registered
        /// email address of an AWS account, or a predefined Amazon S3 group. </p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Access</b>: The permission that you want to give to the AWS user that you
        /// specified in <code>Grantee</code>. Permissions are granted on the thumbnail files
        /// that Elastic Transcoder adds to the bucket. Valid values include: </p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>READ</code>: The grantee can read the thumbnails and metadata for
        /// objects that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>READ_ACP</code>: The grantee can read the object ACL for thumbnails
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>WRITE_ACP</code>: The grantee can write the ACL for the thumbnails
        /// that Elastic Transcoder adds to the Amazon S3 bucket.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FULL_CONTROL</code>: The grantee has <code>READ</code>,
        /// <code>READ_ACP</code>, and <code>WRITE_ACP</code> permissions for the
        /// thumbnails that Elastic Transcoder adds to the Amazon S3 bucket. </p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>
        /// <b>StorageClass</b>: The Amazon S3 storage class, <code>Standard</code> or
        /// <code>ReducedRedundancy</code>, that you want Elastic Transcoder to assign to
        /// the thumbnails that it stores in your Amazon S3 bucket.</p>
        /// </li>
        /// </ul>
        pub fn set_thumbnail_config(
            mut self,
            input: std::option::Option<crate::model::PipelineOutputConfig>,
        ) -> Self {
            self.inner = self.inner.set_thumbnail_config(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdatePipelineNotifications`.
    ///
    /// <p>With the UpdatePipelineNotifications operation, you can update Amazon Simple Notification Service (Amazon SNS) notifications for a pipeline.</p>
    /// <p>When you update notifications for a pipeline, Elastic Transcoder returns the values that you specified in the request.</p>
    #[derive(std::fmt::Debug)]
    pub struct UpdatePipelineNotifications<
        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_pipeline_notifications_input::Builder,
    }
    impl<C, M, R> UpdatePipelineNotifications<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 `UpdatePipelineNotifications`.
        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::UpdatePipelineNotificationsOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdatePipelineNotificationsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UpdatePipelineNotificationsInputOperationOutputAlias,
                crate::output::UpdatePipelineNotificationsOutput,
                crate::error::UpdatePipelineNotificationsError,
                crate::input::UpdatePipelineNotificationsInputOperationRetryAlias,
            >,
        {
            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 identifier of the pipeline for which you want to change notification settings.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The identifier of the pipeline for which you want to change notification settings.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
        /// <p>The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to notify to report job status.</p>
        /// <important>
        /// <p>To receive notifications, you must also subscribe to the new topic in the Amazon SNS console.</p>
        /// </important>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Progressing</b>: The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to
        /// notify when Elastic Transcoder has started to process jobs that are added to this pipeline. This
        /// is the ARN that Amazon SNS returned when you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Complete</b>: The topic ARN for the Amazon SNS topic that you want to notify when
        /// Elastic Transcoder has finished processing a job. This is the ARN that Amazon SNS returned when
        /// you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Warning</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters a warning condition. This is the ARN that Amazon SNS returned when you
        /// created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Error</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters an error condition. This is the ARN that Amazon SNS returned when you
        /// created the topic.</p>
        /// </li>
        /// </ul>
        pub fn notifications(mut self, inp: crate::model::Notifications) -> Self {
            self.inner = self.inner.notifications(inp);
            self
        }
        /// <p>The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to notify to report job status.</p>
        /// <important>
        /// <p>To receive notifications, you must also subscribe to the new topic in the Amazon SNS console.</p>
        /// </important>
        /// <ul>
        /// <li>
        /// <p>
        /// <b>Progressing</b>: The topic ARN for the Amazon Simple Notification Service (Amazon SNS) topic that you want to
        /// notify when Elastic Transcoder has started to process jobs that are added to this pipeline. This
        /// is the ARN that Amazon SNS returned when you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Complete</b>: The topic ARN for the Amazon SNS topic that you want to notify when
        /// Elastic Transcoder has finished processing a job. This is the ARN that Amazon SNS returned when
        /// you created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Warning</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters a warning condition. This is the ARN that Amazon SNS returned when you
        /// created the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <b>Error</b>: The topic ARN for the Amazon SNS topic that you want to notify when Elastic Transcoder
        /// encounters an error condition. This is the ARN that Amazon SNS returned when you
        /// created the topic.</p>
        /// </li>
        /// </ul>
        pub fn set_notifications(
            mut self,
            input: std::option::Option<crate::model::Notifications>,
        ) -> Self {
            self.inner = self.inner.set_notifications(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdatePipelineStatus`.
    ///
    /// <p>The UpdatePipelineStatus operation pauses or reactivates a pipeline, so that the pipeline
    /// stops or restarts the processing of jobs.</p>
    /// <p>Changing the pipeline status is useful if you want to cancel one or more jobs. You can't
    /// cancel jobs after Elastic Transcoder has started processing them; if you pause the pipeline to which
    /// you submitted the jobs, you have more time to get the job IDs for the jobs that you want
    /// to cancel, and to send a <a>CancelJob</a> request. </p>
    #[derive(std::fmt::Debug)]
    pub struct UpdatePipelineStatus<
        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_pipeline_status_input::Builder,
    }
    impl<C, M, R> UpdatePipelineStatus<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 `UpdatePipelineStatus`.
        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::UpdatePipelineStatusOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdatePipelineStatusError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UpdatePipelineStatusInputOperationOutputAlias,
                crate::output::UpdatePipelineStatusOutput,
                crate::error::UpdatePipelineStatusError,
                crate::input::UpdatePipelineStatusInputOperationRetryAlias,
            >,
        {
            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 identifier of the pipeline to update.</p>
        pub fn id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.id(inp);
            self
        }
        /// <p>The identifier of the pipeline to update.</p>
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_id(input);
            self
        }
        /// <p>The desired status of the pipeline:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>Active</code>: The pipeline is processing jobs.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Paused</code>: The pipeline is not currently processing jobs.</p>
        /// </li>
        /// </ul>
        pub fn status(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.status(inp);
            self
        }
        /// <p>The desired status of the pipeline:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>Active</code>: The pipeline is processing jobs.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Paused</code>: The pipeline is not currently processing jobs.</p>
        /// </li>
        /// </ul>
        pub fn set_status(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_status(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 }),
        }
    }
}