// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
use std::fmt::Write;
/// See [`AddPermissionInput`](crate::input::AddPermissionInput)
pub mod add_permission_input {
    /// A builder for [`AddPermissionInput`](crate::input::AddPermissionInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) label: std::option::Option<std::string::String>,
        pub(crate) aws_account_ids: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) actions: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue to which permissions are added.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// <p>The unique identification of the permission you're setting (for example, <code>AliceSendMessage</code>). Maximum 80 characters. Allowed characters include alphanumeric characters, hyphens (<code>-</code>), and underscores (<code>_</code>).</p>
        pub fn label(mut self, input: impl Into<std::string::String>) -> Self {
            self.label = Some(input.into());
            self
        }
        pub fn set_label(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.label = input;
            self
        }
        pub fn aws_account_ids(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.aws_account_ids.unwrap_or_default();
            v.push(input.into());
            self.aws_account_ids = Some(v);
            self
        }
        pub fn set_aws_account_ids(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.aws_account_ids = input;
            self
        }
        pub fn actions(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.actions.unwrap_or_default();
            v.push(input.into());
            self.actions = Some(v);
            self
        }
        pub fn set_actions(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.actions = input;
            self
        }
        /// Consumes the builder and constructs a [`AddPermissionInput`](crate::input::AddPermissionInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::AddPermissionInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::AddPermissionInput {
                queue_url: self.queue_url,
                label: self.label,
                aws_account_ids: self.aws_account_ids,
                actions: self.actions,
            })
        }
    }
}
#[doc(hidden)]
pub type AddPermissionInputOperationOutputAlias = crate::operation::AddPermission;
#[doc(hidden)]
pub type AddPermissionInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl AddPermissionInput {
    /// Consumes the builder and constructs an Operation<[`AddPermission`](crate::operation::AddPermission)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::AddPermission,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_add_permission(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::AddPermission::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "AddPermission",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`AddPermissionInput`](crate::input::AddPermissionInput)
    pub fn builder() -> crate::input::add_permission_input::Builder {
        crate::input::add_permission_input::Builder::default()
    }
}

/// See [`ChangeMessageVisibilityInput`](crate::input::ChangeMessageVisibilityInput)
pub mod change_message_visibility_input {
    /// A builder for [`ChangeMessageVisibilityInput`](crate::input::ChangeMessageVisibilityInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) receipt_handle: std::option::Option<std::string::String>,
        pub(crate) visibility_timeout: std::option::Option<i32>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue whose message's visibility is changed.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// <p>The receipt handle associated with the message whose visibility timeout is changed. This parameter is returned by the <code>
        /// <a>ReceiveMessage</a>
        /// </code> action.</p>
        pub fn receipt_handle(mut self, input: impl Into<std::string::String>) -> Self {
            self.receipt_handle = Some(input.into());
            self
        }
        pub fn set_receipt_handle(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.receipt_handle = input;
            self
        }
        /// <p>The new value for the message's visibility timeout (in seconds). Values range: <code>0</code> to <code>43200</code>. Maximum: 12 hours.</p>
        pub fn visibility_timeout(mut self, input: i32) -> Self {
            self.visibility_timeout = Some(input);
            self
        }
        pub fn set_visibility_timeout(mut self, input: std::option::Option<i32>) -> Self {
            self.visibility_timeout = input;
            self
        }
        /// Consumes the builder and constructs a [`ChangeMessageVisibilityInput`](crate::input::ChangeMessageVisibilityInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::ChangeMessageVisibilityInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::ChangeMessageVisibilityInput {
                queue_url: self.queue_url,
                receipt_handle: self.receipt_handle,
                visibility_timeout: self.visibility_timeout.unwrap_or_default(),
            })
        }
    }
}
#[doc(hidden)]
pub type ChangeMessageVisibilityInputOperationOutputAlias =
    crate::operation::ChangeMessageVisibility;
#[doc(hidden)]
pub type ChangeMessageVisibilityInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ChangeMessageVisibilityInput {
    /// Consumes the builder and constructs an Operation<[`ChangeMessageVisibility`](crate::operation::ChangeMessageVisibility)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::ChangeMessageVisibility,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body = crate::operation_ser::serialize_operation_change_message_visibility(&self)
                .map_err(|err| {
                smithy_http::operation::BuildError::SerializationError(err.into())
            })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::ChangeMessageVisibility::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "ChangeMessageVisibility",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`ChangeMessageVisibilityInput`](crate::input::ChangeMessageVisibilityInput)
    pub fn builder() -> crate::input::change_message_visibility_input::Builder {
        crate::input::change_message_visibility_input::Builder::default()
    }
}

/// See [`ChangeMessageVisibilityBatchInput`](crate::input::ChangeMessageVisibilityBatchInput)
pub mod change_message_visibility_batch_input {
    /// A builder for [`ChangeMessageVisibilityBatchInput`](crate::input::ChangeMessageVisibilityBatchInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) entries: std::option::Option<
            std::vec::Vec<crate::model::ChangeMessageVisibilityBatchRequestEntry>,
        >,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue whose messages' visibility is changed.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        pub fn entries(
            mut self,
            input: impl Into<crate::model::ChangeMessageVisibilityBatchRequestEntry>,
        ) -> Self {
            let mut v = self.entries.unwrap_or_default();
            v.push(input.into());
            self.entries = Some(v);
            self
        }
        pub fn set_entries(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::ChangeMessageVisibilityBatchRequestEntry>,
            >,
        ) -> Self {
            self.entries = input;
            self
        }
        /// Consumes the builder and constructs a [`ChangeMessageVisibilityBatchInput`](crate::input::ChangeMessageVisibilityBatchInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::ChangeMessageVisibilityBatchInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::ChangeMessageVisibilityBatchInput {
                queue_url: self.queue_url,
                entries: self.entries,
            })
        }
    }
}
#[doc(hidden)]
pub type ChangeMessageVisibilityBatchInputOperationOutputAlias =
    crate::operation::ChangeMessageVisibilityBatch;
#[doc(hidden)]
pub type ChangeMessageVisibilityBatchInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ChangeMessageVisibilityBatchInput {
    /// Consumes the builder and constructs an Operation<[`ChangeMessageVisibilityBatch`](crate::operation::ChangeMessageVisibilityBatch)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::ChangeMessageVisibilityBatch,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_change_message_visibility_batch(&self)
                    .map_err(|err| {
                        smithy_http::operation::BuildError::SerializationError(err.into())
                    })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::ChangeMessageVisibilityBatch::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "ChangeMessageVisibilityBatch",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`ChangeMessageVisibilityBatchInput`](crate::input::ChangeMessageVisibilityBatchInput)
    pub fn builder() -> crate::input::change_message_visibility_batch_input::Builder {
        crate::input::change_message_visibility_batch_input::Builder::default()
    }
}

/// See [`CreateQueueInput`](crate::input::CreateQueueInput)
pub mod create_queue_input {
    /// A builder for [`CreateQueueInput`](crate::input::CreateQueueInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
        pub(crate) attributes: std::option::Option<
            std::collections::HashMap<crate::model::QueueAttributeName, std::string::String>,
        >,
    }
    impl Builder {
        /// <p>The name of the new queue. The following limits apply to this name:</p>
        /// <ul>
        /// <li>
        /// <p>A queue name can have up to 80 characters.</p>               
        /// </li>
        /// <li>
        /// <p>Valid values: alphanumeric characters, hyphens (<code>-</code>), and underscores (<code>_</code>).</p>
        /// </li>
        /// <li>
        /// <p>A FIFO queue name must end with the <code>.fifo</code> suffix.</p>
        /// </li>
        /// </ul>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_name = Some(input.into());
            self
        }
        pub fn set_queue_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_name = input;
            self
        }
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.tags.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.tags = Some(hash_map);
            self
        }
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.tags = input;
            self
        }
        pub fn attributes(
            mut self,
            k: impl Into<crate::model::QueueAttributeName>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.attributes.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.attributes = Some(hash_map);
            self
        }
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<crate::model::QueueAttributeName, std::string::String>,
            >,
        ) -> Self {
            self.attributes = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateQueueInput`](crate::input::CreateQueueInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::CreateQueueInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::CreateQueueInput {
                queue_name: self.queue_name,
                tags: self.tags,
                attributes: self.attributes,
            })
        }
    }
}
#[doc(hidden)]
pub type CreateQueueInputOperationOutputAlias = crate::operation::CreateQueue;
#[doc(hidden)]
pub type CreateQueueInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateQueueInput {
    /// Consumes the builder and constructs an Operation<[`CreateQueue`](crate::operation::CreateQueue)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::CreateQueue,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_create_queue(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::CreateQueue::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new("CreateQueue", "sqs"));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`CreateQueueInput`](crate::input::CreateQueueInput)
    pub fn builder() -> crate::input::create_queue_input::Builder {
        crate::input::create_queue_input::Builder::default()
    }
}

/// See [`DeleteMessageInput`](crate::input::DeleteMessageInput)
pub mod delete_message_input {
    /// A builder for [`DeleteMessageInput`](crate::input::DeleteMessageInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) receipt_handle: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue from which messages are deleted.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// <p>The receipt handle associated with the message to delete.</p>
        pub fn receipt_handle(mut self, input: impl Into<std::string::String>) -> Self {
            self.receipt_handle = Some(input.into());
            self
        }
        pub fn set_receipt_handle(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.receipt_handle = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteMessageInput`](crate::input::DeleteMessageInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::DeleteMessageInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::DeleteMessageInput {
                queue_url: self.queue_url,
                receipt_handle: self.receipt_handle,
            })
        }
    }
}
#[doc(hidden)]
pub type DeleteMessageInputOperationOutputAlias = crate::operation::DeleteMessage;
#[doc(hidden)]
pub type DeleteMessageInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteMessageInput {
    /// Consumes the builder and constructs an Operation<[`DeleteMessage`](crate::operation::DeleteMessage)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::DeleteMessage,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_delete_message(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::DeleteMessage::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "DeleteMessage",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`DeleteMessageInput`](crate::input::DeleteMessageInput)
    pub fn builder() -> crate::input::delete_message_input::Builder {
        crate::input::delete_message_input::Builder::default()
    }
}

/// See [`DeleteMessageBatchInput`](crate::input::DeleteMessageBatchInput)
pub mod delete_message_batch_input {
    /// A builder for [`DeleteMessageBatchInput`](crate::input::DeleteMessageBatchInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) entries:
            std::option::Option<std::vec::Vec<crate::model::DeleteMessageBatchRequestEntry>>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue from which messages are deleted.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        pub fn entries(
            mut self,
            input: impl Into<crate::model::DeleteMessageBatchRequestEntry>,
        ) -> Self {
            let mut v = self.entries.unwrap_or_default();
            v.push(input.into());
            self.entries = Some(v);
            self
        }
        pub fn set_entries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DeleteMessageBatchRequestEntry>>,
        ) -> Self {
            self.entries = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteMessageBatchInput`](crate::input::DeleteMessageBatchInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::DeleteMessageBatchInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::DeleteMessageBatchInput {
                queue_url: self.queue_url,
                entries: self.entries,
            })
        }
    }
}
#[doc(hidden)]
pub type DeleteMessageBatchInputOperationOutputAlias = crate::operation::DeleteMessageBatch;
#[doc(hidden)]
pub type DeleteMessageBatchInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteMessageBatchInput {
    /// Consumes the builder and constructs an Operation<[`DeleteMessageBatch`](crate::operation::DeleteMessageBatch)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::DeleteMessageBatch,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body = crate::operation_ser::serialize_operation_delete_message_batch(&self)
                .map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::DeleteMessageBatch::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "DeleteMessageBatch",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`DeleteMessageBatchInput`](crate::input::DeleteMessageBatchInput)
    pub fn builder() -> crate::input::delete_message_batch_input::Builder {
        crate::input::delete_message_batch_input::Builder::default()
    }
}

/// See [`DeleteQueueInput`](crate::input::DeleteQueueInput)
pub mod delete_queue_input {
    /// A builder for [`DeleteQueueInput`](crate::input::DeleteQueueInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue to delete.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteQueueInput`](crate::input::DeleteQueueInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::DeleteQueueInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::DeleteQueueInput {
                queue_url: self.queue_url,
            })
        }
    }
}
#[doc(hidden)]
pub type DeleteQueueInputOperationOutputAlias = crate::operation::DeleteQueue;
#[doc(hidden)]
pub type DeleteQueueInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteQueueInput {
    /// Consumes the builder and constructs an Operation<[`DeleteQueue`](crate::operation::DeleteQueue)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::DeleteQueue,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_delete_queue(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::DeleteQueue::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new("DeleteQueue", "sqs"));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`DeleteQueueInput`](crate::input::DeleteQueueInput)
    pub fn builder() -> crate::input::delete_queue_input::Builder {
        crate::input::delete_queue_input::Builder::default()
    }
}

/// See [`GetQueueAttributesInput`](crate::input::GetQueueAttributesInput)
pub mod get_queue_attributes_input {
    /// A builder for [`GetQueueAttributesInput`](crate::input::GetQueueAttributesInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) attribute_names:
            std::option::Option<std::vec::Vec<crate::model::QueueAttributeName>>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue whose attribute information is retrieved.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        pub fn attribute_names(
            mut self,
            input: impl Into<crate::model::QueueAttributeName>,
        ) -> Self {
            let mut v = self.attribute_names.unwrap_or_default();
            v.push(input.into());
            self.attribute_names = Some(v);
            self
        }
        pub fn set_attribute_names(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::QueueAttributeName>>,
        ) -> Self {
            self.attribute_names = input;
            self
        }
        /// Consumes the builder and constructs a [`GetQueueAttributesInput`](crate::input::GetQueueAttributesInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::GetQueueAttributesInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::GetQueueAttributesInput {
                queue_url: self.queue_url,
                attribute_names: self.attribute_names,
            })
        }
    }
}
#[doc(hidden)]
pub type GetQueueAttributesInputOperationOutputAlias = crate::operation::GetQueueAttributes;
#[doc(hidden)]
pub type GetQueueAttributesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetQueueAttributesInput {
    /// Consumes the builder and constructs an Operation<[`GetQueueAttributes`](crate::operation::GetQueueAttributes)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::GetQueueAttributes,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body = crate::operation_ser::serialize_operation_get_queue_attributes(&self)
                .map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::GetQueueAttributes::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "GetQueueAttributes",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`GetQueueAttributesInput`](crate::input::GetQueueAttributesInput)
    pub fn builder() -> crate::input::get_queue_attributes_input::Builder {
        crate::input::get_queue_attributes_input::Builder::default()
    }
}

/// See [`GetQueueUrlInput`](crate::input::GetQueueUrlInput)
pub mod get_queue_url_input {
    /// A builder for [`GetQueueUrlInput`](crate::input::GetQueueUrlInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_name: std::option::Option<std::string::String>,
        pub(crate) queue_owner_aws_account_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The name of the queue whose URL must be fetched. Maximum 80 characters. Valid values: alphanumeric characters, hyphens (<code>-</code>), and underscores (<code>_</code>).</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_name = Some(input.into());
            self
        }
        pub fn set_queue_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_name = input;
            self
        }
        /// <p>The account ID of the account that created the queue.</p>
        pub fn queue_owner_aws_account_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_owner_aws_account_id = Some(input.into());
            self
        }
        pub fn set_queue_owner_aws_account_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.queue_owner_aws_account_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetQueueUrlInput`](crate::input::GetQueueUrlInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::GetQueueUrlInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::GetQueueUrlInput {
                queue_name: self.queue_name,
                queue_owner_aws_account_id: self.queue_owner_aws_account_id,
            })
        }
    }
}
#[doc(hidden)]
pub type GetQueueUrlInputOperationOutputAlias = crate::operation::GetQueueUrl;
#[doc(hidden)]
pub type GetQueueUrlInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetQueueUrlInput {
    /// Consumes the builder and constructs an Operation<[`GetQueueUrl`](crate::operation::GetQueueUrl)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::GetQueueUrl,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_get_queue_url(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::GetQueueUrl::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new("GetQueueUrl", "sqs"));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`GetQueueUrlInput`](crate::input::GetQueueUrlInput)
    pub fn builder() -> crate::input::get_queue_url_input::Builder {
        crate::input::get_queue_url_input::Builder::default()
    }
}

/// See [`ListDeadLetterSourceQueuesInput`](crate::input::ListDeadLetterSourceQueuesInput)
pub mod list_dead_letter_source_queues_input {
    /// A builder for [`ListDeadLetterSourceQueuesInput`](crate::input::ListDeadLetterSourceQueuesInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) max_results: std::option::Option<i32>,
    }
    impl Builder {
        /// <p>The URL of a dead-letter queue.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// <p>Pagination token to request the next set of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>Maximum number of results to include in the response. Value range is 1 to 1000.
        /// You must set <code>MaxResults</code> to receive a value for <code>NextToken</code> in the response.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.max_results = Some(input);
            self
        }
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.max_results = input;
            self
        }
        /// Consumes the builder and constructs a [`ListDeadLetterSourceQueuesInput`](crate::input::ListDeadLetterSourceQueuesInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::ListDeadLetterSourceQueuesInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::ListDeadLetterSourceQueuesInput {
                queue_url: self.queue_url,
                next_token: self.next_token,
                max_results: self.max_results,
            })
        }
    }
}
#[doc(hidden)]
pub type ListDeadLetterSourceQueuesInputOperationOutputAlias =
    crate::operation::ListDeadLetterSourceQueues;
#[doc(hidden)]
pub type ListDeadLetterSourceQueuesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListDeadLetterSourceQueuesInput {
    /// Consumes the builder and constructs an Operation<[`ListDeadLetterSourceQueues`](crate::operation::ListDeadLetterSourceQueues)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::ListDeadLetterSourceQueues,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_list_dead_letter_source_queues(&self)
                    .map_err(|err| {
                        smithy_http::operation::BuildError::SerializationError(err.into())
                    })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::ListDeadLetterSourceQueues::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "ListDeadLetterSourceQueues",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`ListDeadLetterSourceQueuesInput`](crate::input::ListDeadLetterSourceQueuesInput)
    pub fn builder() -> crate::input::list_dead_letter_source_queues_input::Builder {
        crate::input::list_dead_letter_source_queues_input::Builder::default()
    }
}

/// See [`ListQueuesInput`](crate::input::ListQueuesInput)
pub mod list_queues_input {
    /// A builder for [`ListQueuesInput`](crate::input::ListQueuesInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_name_prefix: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) max_results: std::option::Option<i32>,
    }
    impl Builder {
        /// <p>A string to use for filtering the list results. Only those queues whose name begins with the specified string are returned.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_name_prefix(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_name_prefix = Some(input.into());
            self
        }
        pub fn set_queue_name_prefix(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.queue_name_prefix = input;
            self
        }
        /// <p>Pagination token to request the next set of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>Maximum number of results to include in the response. Value range is 1 to 1000.
        /// You must set <code>MaxResults</code> to receive a value for <code>NextToken</code> in the response.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.max_results = Some(input);
            self
        }
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.max_results = input;
            self
        }
        /// Consumes the builder and constructs a [`ListQueuesInput`](crate::input::ListQueuesInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::ListQueuesInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::ListQueuesInput {
                queue_name_prefix: self.queue_name_prefix,
                next_token: self.next_token,
                max_results: self.max_results,
            })
        }
    }
}
#[doc(hidden)]
pub type ListQueuesInputOperationOutputAlias = crate::operation::ListQueues;
#[doc(hidden)]
pub type ListQueuesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListQueuesInput {
    /// Consumes the builder and constructs an Operation<[`ListQueues`](crate::operation::ListQueues)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::ListQueues,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_list_queues(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::ListQueues::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new("ListQueues", "sqs"));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`ListQueuesInput`](crate::input::ListQueuesInput)
    pub fn builder() -> crate::input::list_queues_input::Builder {
        crate::input::list_queues_input::Builder::default()
    }
}

/// See [`ListQueueTagsInput`](crate::input::ListQueueTagsInput)
pub mod list_queue_tags_input {
    /// A builder for [`ListQueueTagsInput`](crate::input::ListQueueTagsInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The URL of the queue.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// Consumes the builder and constructs a [`ListQueueTagsInput`](crate::input::ListQueueTagsInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::ListQueueTagsInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::ListQueueTagsInput {
                queue_url: self.queue_url,
            })
        }
    }
}
#[doc(hidden)]
pub type ListQueueTagsInputOperationOutputAlias = crate::operation::ListQueueTags;
#[doc(hidden)]
pub type ListQueueTagsInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListQueueTagsInput {
    /// Consumes the builder and constructs an Operation<[`ListQueueTags`](crate::operation::ListQueueTags)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::ListQueueTags,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body = crate::operation_ser::serialize_operation_list_queue_tags(&self).map_err(
                |err| smithy_http::operation::BuildError::SerializationError(err.into()),
            )?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::ListQueueTags::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "ListQueueTags",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`ListQueueTagsInput`](crate::input::ListQueueTagsInput)
    pub fn builder() -> crate::input::list_queue_tags_input::Builder {
        crate::input::list_queue_tags_input::Builder::default()
    }
}

/// See [`PurgeQueueInput`](crate::input::PurgeQueueInput)
pub mod purge_queue_input {
    /// A builder for [`PurgeQueueInput`](crate::input::PurgeQueueInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The URL of the queue from which the <code>PurgeQueue</code> action deletes messages.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// Consumes the builder and constructs a [`PurgeQueueInput`](crate::input::PurgeQueueInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::PurgeQueueInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::PurgeQueueInput {
                queue_url: self.queue_url,
            })
        }
    }
}
#[doc(hidden)]
pub type PurgeQueueInputOperationOutputAlias = crate::operation::PurgeQueue;
#[doc(hidden)]
pub type PurgeQueueInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl PurgeQueueInput {
    /// Consumes the builder and constructs an Operation<[`PurgeQueue`](crate::operation::PurgeQueue)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::PurgeQueue,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_purge_queue(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::PurgeQueue::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new("PurgeQueue", "sqs"));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`PurgeQueueInput`](crate::input::PurgeQueueInput)
    pub fn builder() -> crate::input::purge_queue_input::Builder {
        crate::input::purge_queue_input::Builder::default()
    }
}

/// See [`ReceiveMessageInput`](crate::input::ReceiveMessageInput)
pub mod receive_message_input {
    /// A builder for [`ReceiveMessageInput`](crate::input::ReceiveMessageInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) attribute_names:
            std::option::Option<std::vec::Vec<crate::model::QueueAttributeName>>,
        pub(crate) message_attribute_names: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) max_number_of_messages: std::option::Option<i32>,
        pub(crate) visibility_timeout: std::option::Option<i32>,
        pub(crate) wait_time_seconds: std::option::Option<i32>,
        pub(crate) receive_request_attempt_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue from which messages are received.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        pub fn attribute_names(
            mut self,
            input: impl Into<crate::model::QueueAttributeName>,
        ) -> Self {
            let mut v = self.attribute_names.unwrap_or_default();
            v.push(input.into());
            self.attribute_names = Some(v);
            self
        }
        pub fn set_attribute_names(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::QueueAttributeName>>,
        ) -> Self {
            self.attribute_names = input;
            self
        }
        pub fn message_attribute_names(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.message_attribute_names.unwrap_or_default();
            v.push(input.into());
            self.message_attribute_names = Some(v);
            self
        }
        pub fn set_message_attribute_names(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.message_attribute_names = input;
            self
        }
        /// <p>The maximum number of messages to return. Amazon SQS never returns more messages than this value (however, fewer messages might be returned). Valid values: 1 to 10. Default: 1.</p>
        pub fn max_number_of_messages(mut self, input: i32) -> Self {
            self.max_number_of_messages = Some(input);
            self
        }
        pub fn set_max_number_of_messages(mut self, input: std::option::Option<i32>) -> Self {
            self.max_number_of_messages = input;
            self
        }
        /// <p>The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a <code>ReceiveMessage</code> request.</p>
        pub fn visibility_timeout(mut self, input: i32) -> Self {
            self.visibility_timeout = Some(input);
            self
        }
        pub fn set_visibility_timeout(mut self, input: std::option::Option<i32>) -> Self {
            self.visibility_timeout = input;
            self
        }
        /// <p>The duration (in seconds) for which the call waits for a message to arrive in the queue before returning. If a message is available, the call returns sooner than <code>WaitTimeSeconds</code>.
        /// If no messages are available and the wait time expires, the call returns successfully with an empty list of messages.</p>
        /// <important>
        /// <p>To avoid HTTP errors, ensure that the HTTP response timeout for <code>ReceiveMessage</code>
        /// requests is longer than the <code>WaitTimeSeconds</code> parameter. For example,
        /// with the Java SDK, you can set HTTP transport settings using the <a href="https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html"> NettyNioAsyncHttpClient</a> for asynchronous clients, or the <a href="https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html"> ApacheHttpClient</a> for synchronous clients. </p>
        /// </important>
        pub fn wait_time_seconds(mut self, input: i32) -> Self {
            self.wait_time_seconds = Some(input);
            self
        }
        pub fn set_wait_time_seconds(mut self, input: std::option::Option<i32>) -> Self {
            self.wait_time_seconds = input;
            self
        }
        /// <p>This parameter applies only to FIFO (first-in-first-out) queues.</p>
        /// <p>The token used for deduplication of <code>ReceiveMessage</code> calls. If a networking issue occurs after a <code>ReceiveMessage</code> action, and instead of a response you receive a generic error,
        /// it is possible to retry the same action with an identical <code>ReceiveRequestAttemptId</code> to retrieve the same set of messages, even if their visibility timeout has not yet expired.</p>
        /// <ul>
        /// <li>
        /// <p>You can use <code>ReceiveRequestAttemptId</code> only for 5 minutes after a <code>ReceiveMessage</code> action.</p>
        /// </li>
        /// <li>
        /// <p>When you set <code>FifoQueue</code>, a caller of the <code>ReceiveMessage</code> action can provide a <code>ReceiveRequestAttemptId</code> explicitly.</p>
        /// </li>
        /// <li>
        /// <p>If a caller of the <code>ReceiveMessage</code> action doesn't provide a <code>ReceiveRequestAttemptId</code>, Amazon SQS generates a <code>ReceiveRequestAttemptId</code>.</p>
        /// </li>
        /// <li>
        /// <p>It is possible to retry the <code>ReceiveMessage</code> action with the same <code>ReceiveRequestAttemptId</code> if none of the messages have been modified (deleted or had their visibility changes).</p>
        /// </li>
        /// <li>
        /// <p>During a visibility timeout, subsequent calls with the same <code>ReceiveRequestAttemptId</code> return the same messages and receipt handles. If a retry occurs within the deduplication interval,
        /// it resets the visibility timeout. For more information, see
        /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html">Visibility Timeout</a>
        /// in the <i>Amazon SQS Developer Guide</i>.</p>
        /// <important>
        /// <p>If a caller of the <code>ReceiveMessage</code> action still processes
        /// messages when the visibility timeout expires and messages become visible,
        /// another worker consuming from the same queue can receive the same messages
        /// and therefore process duplicates. Also, if a consumer whose message
        /// processing time is longer than the visibility timeout tries to delete the
        /// processed messages, the action fails with an error.</p>
        /// <p>To mitigate this effect, ensure that your application observes a safe threshold before the visibility timeout expires and extend the visibility timeout as necessary.</p>
        /// </important>
        /// </li>
        /// <li>
        /// <p>While messages with a particular <code>MessageGroupId</code> are invisible, no more messages belonging to the same <code>MessageGroupId</code> are returned until the visibility timeout expires. You can still receive
        /// messages with another <code>MessageGroupId</code> as long as it is also visible.</p>
        /// </li>
        /// <li>
        /// <p>If a caller of <code>ReceiveMessage</code> can't track the <code>ReceiveRequestAttemptId</code>, no retries work until the original visibility timeout expires. As a result, delays might occur but
        /// the messages in the queue remain in a strict order.</p>
        /// </li>
        /// </ul>
        /// <p>The maximum length of <code>ReceiveRequestAttemptId</code> is 128 characters. <code>ReceiveRequestAttemptId</code> can contain alphanumeric characters (<code>a-z</code>, <code>A-Z</code>, <code>0-9</code>) and
        /// punctuation (<code>!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~</code>).</p>
        /// <p>For best practices of using <code>ReceiveRequestAttemptId</code>, see
        /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-receiverequestattemptid-request-parameter.html">Using the ReceiveRequestAttemptId Request Parameter</a>
        /// in the <i>Amazon SQS Developer Guide</i>.</p>
        pub fn receive_request_attempt_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.receive_request_attempt_id = Some(input.into());
            self
        }
        pub fn set_receive_request_attempt_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.receive_request_attempt_id = input;
            self
        }
        /// Consumes the builder and constructs a [`ReceiveMessageInput`](crate::input::ReceiveMessageInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::ReceiveMessageInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::ReceiveMessageInput {
                queue_url: self.queue_url,
                attribute_names: self.attribute_names,
                message_attribute_names: self.message_attribute_names,
                max_number_of_messages: self.max_number_of_messages.unwrap_or_default(),
                visibility_timeout: self.visibility_timeout.unwrap_or_default(),
                wait_time_seconds: self.wait_time_seconds.unwrap_or_default(),
                receive_request_attempt_id: self.receive_request_attempt_id,
            })
        }
    }
}
#[doc(hidden)]
pub type ReceiveMessageInputOperationOutputAlias = crate::operation::ReceiveMessage;
#[doc(hidden)]
pub type ReceiveMessageInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ReceiveMessageInput {
    /// Consumes the builder and constructs an Operation<[`ReceiveMessage`](crate::operation::ReceiveMessage)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::ReceiveMessage,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body = crate::operation_ser::serialize_operation_receive_message(&self).map_err(
                |err| smithy_http::operation::BuildError::SerializationError(err.into()),
            )?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::ReceiveMessage::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "ReceiveMessage",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`ReceiveMessageInput`](crate::input::ReceiveMessageInput)
    pub fn builder() -> crate::input::receive_message_input::Builder {
        crate::input::receive_message_input::Builder::default()
    }
}

/// See [`RemovePermissionInput`](crate::input::RemovePermissionInput)
pub mod remove_permission_input {
    /// A builder for [`RemovePermissionInput`](crate::input::RemovePermissionInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) label: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue from which permissions are removed.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// <p>The identification of the permission to remove. This is the label added using the <code>
        /// <a>AddPermission</a>
        /// </code> action.</p>
        pub fn label(mut self, input: impl Into<std::string::String>) -> Self {
            self.label = Some(input.into());
            self
        }
        pub fn set_label(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.label = input;
            self
        }
        /// Consumes the builder and constructs a [`RemovePermissionInput`](crate::input::RemovePermissionInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::RemovePermissionInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::RemovePermissionInput {
                queue_url: self.queue_url,
                label: self.label,
            })
        }
    }
}
#[doc(hidden)]
pub type RemovePermissionInputOperationOutputAlias = crate::operation::RemovePermission;
#[doc(hidden)]
pub type RemovePermissionInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl RemovePermissionInput {
    /// Consumes the builder and constructs an Operation<[`RemovePermission`](crate::operation::RemovePermission)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::RemovePermission,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body = crate::operation_ser::serialize_operation_remove_permission(&self).map_err(
                |err| smithy_http::operation::BuildError::SerializationError(err.into()),
            )?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::RemovePermission::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "RemovePermission",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`RemovePermissionInput`](crate::input::RemovePermissionInput)
    pub fn builder() -> crate::input::remove_permission_input::Builder {
        crate::input::remove_permission_input::Builder::default()
    }
}

/// See [`SendMessageInput`](crate::input::SendMessageInput)
pub mod send_message_input {
    /// A builder for [`SendMessageInput`](crate::input::SendMessageInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) message_body: std::option::Option<std::string::String>,
        pub(crate) delay_seconds: std::option::Option<i32>,
        pub(crate) message_attributes: std::option::Option<
            std::collections::HashMap<std::string::String, crate::model::MessageAttributeValue>,
        >,
        pub(crate) message_system_attributes: std::option::Option<
            std::collections::HashMap<
                crate::model::MessageSystemAttributeNameForSends,
                crate::model::MessageSystemAttributeValue,
            >,
        >,
        pub(crate) message_deduplication_id: std::option::Option<std::string::String>,
        pub(crate) message_group_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue to which a message is sent.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        /// <p>The message to send. The minimum size is one character. The maximum size is 256 KB.</p>
        /// <important>
        /// <p>A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed:</p>
        /// <p>
        /// <code>#x9</code> | <code>#xA</code> | <code>#xD</code> | <code>#x20</code> to <code>#xD7FF</code> | <code>#xE000</code> to <code>#xFFFD</code> | <code>#x10000</code> to <code>#x10FFFF</code>
        /// </p>
        /// <p>Any characters not included in this list will be rejected. For more information, see the <a href="http://www.w3.org/TR/REC-xml/#charsets">W3C specification for characters</a>.</p>
        /// </important>
        pub fn message_body(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_body = Some(input.into());
            self
        }
        pub fn set_message_body(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message_body = input;
            self
        }
        /// <p>
        /// The length of time, in seconds, for which to delay a specific message. Valid values: 0 to 900. Maximum: 15 minutes. Messages with a positive <code>DelaySeconds</code> value become available for processing after the delay period is finished.
        /// If you don't specify a value, the default value for the queue applies.
        /// </p>
        /// <note>
        /// <p>When you set <code>FifoQueue</code>, you can't set <code>DelaySeconds</code> per message. You can set this parameter only on a queue level.</p>
        /// </note>
        pub fn delay_seconds(mut self, input: i32) -> Self {
            self.delay_seconds = Some(input);
            self
        }
        pub fn set_delay_seconds(mut self, input: std::option::Option<i32>) -> Self {
            self.delay_seconds = input;
            self
        }
        pub fn message_attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<crate::model::MessageAttributeValue>,
        ) -> Self {
            let mut hash_map = self.message_attributes.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.message_attributes = Some(hash_map);
            self
        }
        pub fn set_message_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, crate::model::MessageAttributeValue>,
            >,
        ) -> Self {
            self.message_attributes = input;
            self
        }
        pub fn message_system_attributes(
            mut self,
            k: impl Into<crate::model::MessageSystemAttributeNameForSends>,
            v: impl Into<crate::model::MessageSystemAttributeValue>,
        ) -> Self {
            let mut hash_map = self.message_system_attributes.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.message_system_attributes = Some(hash_map);
            self
        }
        pub fn set_message_system_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<
                    crate::model::MessageSystemAttributeNameForSends,
                    crate::model::MessageSystemAttributeValue,
                >,
            >,
        ) -> Self {
            self.message_system_attributes = input;
            self
        }
        /// <p>This parameter applies only to FIFO (first-in-first-out) queues.</p>
        /// <p>The token used for deduplication of sent messages. If a message with a particular <code>MessageDeduplicationId</code> is sent successfully, any messages sent with the same <code>MessageDeduplicationId</code>
        /// are accepted successfully but aren't delivered during the 5-minute deduplication interval. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues-exactly-once-processing.html">
        /// Exactly-once processing</a> in the <i>Amazon SQS Developer Guide</i>.</p>
        /// <ul>
        /// <li>
        /// <p>Every message must have a unique <code>MessageDeduplicationId</code>,</p>
        /// <ul>
        /// <li>
        /// <p>You may provide a <code>MessageDeduplicationId</code> explicitly.</p>
        /// </li>
        /// <li>
        /// <p>If you aren't able to provide a <code>MessageDeduplicationId</code> and you enable <code>ContentBasedDeduplication</code> for your queue,
        /// Amazon SQS uses a SHA-256 hash to generate the <code>MessageDeduplicationId</code> using the body of the message (but not the attributes of the message).
        /// </p>
        /// </li>
        /// <li>
        /// <p>If you don't provide a <code>MessageDeduplicationId</code> and the queue doesn't have <code>ContentBasedDeduplication</code> set,
        /// the action fails with an error.</p>
        /// </li>
        /// <li>
        /// <p>If the queue has <code>ContentBasedDeduplication</code> set, your <code>MessageDeduplicationId</code> overrides the generated one.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// <li>
        /// <p>When <code>ContentBasedDeduplication</code> is in effect, messages with identical content sent within the deduplication interval are treated as duplicates
        /// and only one copy of the message is delivered.</p>
        /// </li>
        /// <li>
        /// <p>If you send one message with <code>ContentBasedDeduplication</code> enabled and then another message with a <code>MessageDeduplicationId</code> that is the same
        /// as the one generated for the first <code>MessageDeduplicationId</code>, the two messages are treated as duplicates and only one copy of the message is delivered.
        /// </p>
        /// </li>
        /// </ul>
        /// <note>
        /// <p>The <code>MessageDeduplicationId</code> is available to the consumer of the
        /// message (this can be useful for troubleshooting delivery issues).</p>
        /// <p>If a message is sent successfully but the acknowledgement is lost and the message is resent with the same
        /// <code>MessageDeduplicationId</code> after the deduplication interval, Amazon SQS can't detect duplicate messages.</p>
        /// <p>Amazon SQS continues to keep track of the message deduplication ID even after the message is received and deleted.</p>
        /// </note>
        /// <p>The maximum length of <code>MessageDeduplicationId</code> is 128 characters. <code>MessageDeduplicationId</code> can contain alphanumeric characters (<code>a-z</code>, <code>A-Z</code>, <code>0-9</code>) and
        /// punctuation (<code>!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~</code>).</p>
        /// <p>For best practices of using <code>MessageDeduplicationId</code>, see
        /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-messagededuplicationid-property.html">Using the MessageDeduplicationId Property</a>
        /// in the <i>Amazon SQS Developer Guide</i>.</p>
        pub fn message_deduplication_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_deduplication_id = Some(input.into());
            self
        }
        pub fn set_message_deduplication_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.message_deduplication_id = input;
            self
        }
        /// <p>This parameter applies only to FIFO (first-in-first-out) queues.</p>
        /// <p>The tag that specifies that a message belongs to a specific message group. Messages
        /// that belong to the same message group are processed in a FIFO manner (however,
        /// messages in different message groups might be processed out of order). To interleave
        /// multiple ordered streams within a single queue, use <code>MessageGroupId</code> values
        /// (for example, session data for multiple users). In this scenario, multiple consumers can
        /// process the queue, but the session data of each user is processed in a FIFO
        /// fashion.</p>
        /// <ul>
        /// <li>
        /// <p>You must associate a non-empty <code>MessageGroupId</code> with a message. If you don't provide a <code>MessageGroupId</code>, the action fails.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>ReceiveMessage</code> might return messages with multiple <code>MessageGroupId</code> values. For each <code>MessageGroupId</code>, the messages are sorted by time sent. The caller can't
        /// specify a <code>MessageGroupId</code>.</p>
        /// </li>
        /// </ul>
        /// <p>The length of <code>MessageGroupId</code> is 128 characters. Valid values: alphanumeric characters and punctuation <code>(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)</code>.</p>
        /// <p>For best practices of using <code>MessageGroupId</code>, see
        /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-messagegroupid-property.html">Using the MessageGroupId Property</a>
        /// in the <i>Amazon SQS Developer Guide</i>.</p>
        /// <important>
        /// <p>
        /// <code>MessageGroupId</code> is required for FIFO queues. You can't use it for Standard queues.</p>
        /// </important>
        pub fn message_group_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_group_id = Some(input.into());
            self
        }
        pub fn set_message_group_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.message_group_id = input;
            self
        }
        /// Consumes the builder and constructs a [`SendMessageInput`](crate::input::SendMessageInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::SendMessageInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::SendMessageInput {
                queue_url: self.queue_url,
                message_body: self.message_body,
                delay_seconds: self.delay_seconds.unwrap_or_default(),
                message_attributes: self.message_attributes,
                message_system_attributes: self.message_system_attributes,
                message_deduplication_id: self.message_deduplication_id,
                message_group_id: self.message_group_id,
            })
        }
    }
}
#[doc(hidden)]
pub type SendMessageInputOperationOutputAlias = crate::operation::SendMessage;
#[doc(hidden)]
pub type SendMessageInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SendMessageInput {
    /// Consumes the builder and constructs an Operation<[`SendMessage`](crate::operation::SendMessage)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::SendMessage,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_send_message(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::SendMessage::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new("SendMessage", "sqs"));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`SendMessageInput`](crate::input::SendMessageInput)
    pub fn builder() -> crate::input::send_message_input::Builder {
        crate::input::send_message_input::Builder::default()
    }
}

/// See [`SendMessageBatchInput`](crate::input::SendMessageBatchInput)
pub mod send_message_batch_input {
    /// A builder for [`SendMessageBatchInput`](crate::input::SendMessageBatchInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) entries:
            std::option::Option<std::vec::Vec<crate::model::SendMessageBatchRequestEntry>>,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue to which batched messages are sent.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        pub fn entries(
            mut self,
            input: impl Into<crate::model::SendMessageBatchRequestEntry>,
        ) -> Self {
            let mut v = self.entries.unwrap_or_default();
            v.push(input.into());
            self.entries = Some(v);
            self
        }
        pub fn set_entries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::SendMessageBatchRequestEntry>>,
        ) -> Self {
            self.entries = input;
            self
        }
        /// Consumes the builder and constructs a [`SendMessageBatchInput`](crate::input::SendMessageBatchInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::SendMessageBatchInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::SendMessageBatchInput {
                queue_url: self.queue_url,
                entries: self.entries,
            })
        }
    }
}
#[doc(hidden)]
pub type SendMessageBatchInputOperationOutputAlias = crate::operation::SendMessageBatch;
#[doc(hidden)]
pub type SendMessageBatchInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SendMessageBatchInput {
    /// Consumes the builder and constructs an Operation<[`SendMessageBatch`](crate::operation::SendMessageBatch)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::SendMessageBatch,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body = crate::operation_ser::serialize_operation_send_message_batch(&self)
                .map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::SendMessageBatch::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "SendMessageBatch",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`SendMessageBatchInput`](crate::input::SendMessageBatchInput)
    pub fn builder() -> crate::input::send_message_batch_input::Builder {
        crate::input::send_message_batch_input::Builder::default()
    }
}

/// See [`SetQueueAttributesInput`](crate::input::SetQueueAttributesInput)
pub mod set_queue_attributes_input {
    /// A builder for [`SetQueueAttributesInput`](crate::input::SetQueueAttributesInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) attributes: std::option::Option<
            std::collections::HashMap<crate::model::QueueAttributeName, std::string::String>,
        >,
    }
    impl Builder {
        /// <p>The URL of the Amazon SQS queue whose attributes are set.</p>
        /// <p>Queue URLs and names are case-sensitive.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        pub fn attributes(
            mut self,
            k: impl Into<crate::model::QueueAttributeName>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.attributes.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.attributes = Some(hash_map);
            self
        }
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<crate::model::QueueAttributeName, std::string::String>,
            >,
        ) -> Self {
            self.attributes = input;
            self
        }
        /// Consumes the builder and constructs a [`SetQueueAttributesInput`](crate::input::SetQueueAttributesInput)
        pub fn build(
            self,
        ) -> std::result::Result<
            crate::input::SetQueueAttributesInput,
            smithy_http::operation::BuildError,
        > {
            Ok(crate::input::SetQueueAttributesInput {
                queue_url: self.queue_url,
                attributes: self.attributes,
            })
        }
    }
}
#[doc(hidden)]
pub type SetQueueAttributesInputOperationOutputAlias = crate::operation::SetQueueAttributes;
#[doc(hidden)]
pub type SetQueueAttributesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SetQueueAttributesInput {
    /// Consumes the builder and constructs an Operation<[`SetQueueAttributes`](crate::operation::SetQueueAttributes)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::SetQueueAttributes,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body = crate::operation_ser::serialize_operation_set_queue_attributes(&self)
                .map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::SetQueueAttributes::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new(
                "SetQueueAttributes",
                "sqs",
            ));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`SetQueueAttributesInput`](crate::input::SetQueueAttributesInput)
    pub fn builder() -> crate::input::set_queue_attributes_input::Builder {
        crate::input::set_queue_attributes_input::Builder::default()
    }
}

/// See [`TagQueueInput`](crate::input::TagQueueInput)
pub mod tag_queue_input {
    /// A builder for [`TagQueueInput`](crate::input::TagQueueInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// <p>The URL of the queue.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.tags.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.tags = Some(hash_map);
            self
        }
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`TagQueueInput`](crate::input::TagQueueInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::TagQueueInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::TagQueueInput {
                queue_url: self.queue_url,
                tags: self.tags,
            })
        }
    }
}
#[doc(hidden)]
pub type TagQueueInputOperationOutputAlias = crate::operation::TagQueue;
#[doc(hidden)]
pub type TagQueueInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl TagQueueInput {
    /// Consumes the builder and constructs an Operation<[`TagQueue`](crate::operation::TagQueue)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::TagQueue,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_tag_queue(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op =
                smithy_http::operation::Operation::new(request, crate::operation::TagQueue::new())
                    .with_metadata(smithy_http::operation::Metadata::new("TagQueue", "sqs"));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`TagQueueInput`](crate::input::TagQueueInput)
    pub fn builder() -> crate::input::tag_queue_input::Builder {
        crate::input::tag_queue_input::Builder::default()
    }
}

/// See [`UntagQueueInput`](crate::input::UntagQueueInput)
pub mod untag_queue_input {
    /// A builder for [`UntagQueueInput`](crate::input::UntagQueueInput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queue_url: std::option::Option<std::string::String>,
        pub(crate) tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        /// <p>The URL of the queue.</p>
        pub fn queue_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.queue_url = Some(input.into());
            self
        }
        pub fn set_queue_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.queue_url = input;
            self
        }
        pub fn tag_keys(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.tag_keys.unwrap_or_default();
            v.push(input.into());
            self.tag_keys = Some(v);
            self
        }
        pub fn set_tag_keys(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.tag_keys = input;
            self
        }
        /// Consumes the builder and constructs a [`UntagQueueInput`](crate::input::UntagQueueInput)
        pub fn build(
            self,
        ) -> std::result::Result<crate::input::UntagQueueInput, smithy_http::operation::BuildError>
        {
            Ok(crate::input::UntagQueueInput {
                queue_url: self.queue_url,
                tag_keys: self.tag_keys,
            })
        }
    }
}
#[doc(hidden)]
pub type UntagQueueInputOperationOutputAlias = crate::operation::UntagQueue;
#[doc(hidden)]
pub type UntagQueueInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UntagQueueInput {
    /// Consumes the builder and constructs an Operation<[`UntagQueue`](crate::operation::UntagQueue)>
    #[allow(clippy::let_and_return)]
    pub fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        smithy_http::operation::Operation<
            crate::operation::UntagQueue,
            aws_http::AwsErrorRetryPolicy,
        >,
        smithy_http::operation::BuildError,
    > {
        Ok({
            let request = self.request_builder_base()?;
            let body =
                crate::operation_ser::serialize_operation_untag_queue(&self).map_err(|err| {
                    smithy_http::operation::BuildError::SerializationError(err.into())
                })?;
            let request = Self::assemble(request, body);
            #[allow(unused_mut)]
            let mut request =
                smithy_http::operation::Request::new(request.map(smithy_http::body::SdkBody::from));
            request.properties_mut().insert(
                aws_http::user_agent::AwsUserAgent::new_from_environment(
                    crate::API_METADATA.clone(),
                ),
            );
            #[allow(unused_mut)]
            let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
            request.properties_mut().insert(signing_config);
            request
                .properties_mut()
                .insert(aws_types::SigningService::from_static(
                    _config.signing_service(),
                ));
            aws_endpoint::set_endpoint_resolver(
                &mut request.properties_mut(),
                _config.endpoint_resolver.clone(),
            );
            if let Some(region) = &_config.region {
                request.properties_mut().insert(region.clone());
            }
            aws_auth::provider::set_provider(
                &mut request.properties_mut(),
                _config.credentials_provider.clone(),
            );
            let op = smithy_http::operation::Operation::new(
                request,
                crate::operation::UntagQueue::new(),
            )
            .with_metadata(smithy_http::operation::Metadata::new("UntagQueue", "sqs"));
            let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
            op
        })
    }
    fn uri_base(&self, output: &mut String) -> Result<(), smithy_http::operation::BuildError> {
        write!(output, "/").expect("formatting should succeed");
        Ok(())
    }
    #[allow(clippy::unnecessary_wraps)]
    fn update_http_builder(
        &self,
        builder: http::request::Builder,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut uri = String::new();
        self.uri_base(&mut uri)?;
        Ok(builder.method("POST").uri(uri))
    }
    #[allow(clippy::unnecessary_wraps)]
    fn request_builder_base(
        &self,
    ) -> std::result::Result<http::request::Builder, smithy_http::operation::BuildError> {
        let mut builder = self.update_http_builder(http::request::Builder::new())?;
        builder = smithy_http::header::set_header_if_absent(
            builder,
            "content-type",
            "application/x-www-form-urlencoded",
        );
        Ok(builder)
    }
    fn assemble(
        mut builder: http::request::Builder,
        body: smithy_http::body::SdkBody,
    ) -> http::request::Request<smithy_http::body::SdkBody> {
        if let Some(content_length) = body.content_length() {
            builder = builder.header(http::header::CONTENT_LENGTH, content_length)
        }
        builder.body(body).expect("should be valid request")
    }
    /// Creates a new builder-style object to manufacture [`UntagQueueInput`](crate::input::UntagQueueInput)
    pub fn builder() -> crate::input::untag_queue_input::Builder {
        crate::input::untag_queue_input::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UntagQueueInput {
    /// <p>The URL of the queue.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>The list of tags to be removed from the specified queue.</p>
    pub tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl std::fmt::Debug for UntagQueueInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UntagQueueInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("tag_keys", &self.tag_keys);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct TagQueueInput {
    /// <p>The URL of the queue.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>The list of tags to be added to the specified queue.</p>
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl std::fmt::Debug for TagQueueInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("TagQueueInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SetQueueAttributesInput {
    /// <p>The URL of the Amazon SQS queue whose attributes are set.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>A map of attributes to set.</p>
    /// <p>The following lists the names, descriptions, and values of the special request parameters that the <code>SetQueueAttributes</code> action uses:</p>      
    /// <ul>
    /// <li>
    /// <p>
    /// <code>DelaySeconds</code> – The length of time, in seconds, for which the delivery of all messages in the queue is delayed. Valid values: An integer from 0 to 900 (15 minutes). Default: 0.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MaximumMessageSize</code> – The limit of how many bytes a message can contain before Amazon SQS rejects it. Valid values: An integer from 1,024 bytes (1 KiB) up to 262,144 bytes (256 KiB). Default: 262,144 (256 KiB).
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MessageRetentionPeriod</code> – The length of time, in seconds, for which Amazon SQS retains a message. Valid values: An integer representing seconds, from 60 (1 minute) to 1,209,600 (14 days). Default: 345,600 (4 days).
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>Policy</code> – The queue's policy. A valid Amazon Web Services policy. For more information about policy structure, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/PoliciesOverview.html">Overview of Amazon Web Services IAM Policies</a>
    /// in the <i>Identity and Access Management User Guide</i>.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ReceiveMessageWaitTimeSeconds</code> – The length of time, in seconds, for which a <code>
    /// <a>ReceiveMessage</a>
    /// </code> action waits for a message to arrive. Valid values: An integer from 0 to 20 (seconds). Default: 0.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>RedrivePolicy</code> – The string that includes the parameters for the dead-letter queue functionality
    /// of the source queue as a JSON object. For more information about the redrive policy and dead-letter queues, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html">Using Amazon SQS Dead-Letter Queues</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>deadLetterTargetArn</code> – The Amazon Resource Name (ARN) of the dead-letter queue to which Amazon SQS moves messages after the value of <code>maxReceiveCount</code> is exceeded.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>maxReceiveCount</code> – The number of times a message is delivered to the source queue before being moved to the dead-letter queue.
    /// When the <code>ReceiveCount</code> for a message exceeds the <code>maxReceiveCount</code> for a queue, Amazon SQS moves the message to the dead-letter-queue.</p>
    /// </li>
    /// </ul>
    /// <note>
    /// <p>The dead-letter queue of a FIFO queue must also be a FIFO queue. Similarly, the dead-letter queue of a standard queue must also be a standard queue.</p>
    /// </note>
    /// </li>
    /// <li>
    /// <p>
    /// <code>VisibilityTimeout</code> – The visibility timeout for the queue, in seconds. Valid values: An integer from 0 to 43,200 (12 hours). Default: 30. For more information about the visibility timeout,
    /// see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html">Visibility Timeout</a> in the <i>Amazon SQS Developer Guide</i>.</p>
    /// </li>
    /// </ul>
    /// <p>The following attributes apply only to <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html">server-side-encryption</a>:</p>     
    /// <ul>
    /// <li>
    /// <p>
    /// <code>KmsMasterKeyId</code> – The ID of an Amazon Web Services managed customer master key (CMK) for Amazon SQS or a custom CMK. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-sse-key-terms">Key Terms</a>.
    /// While the alias of the AWS-managed CMK for Amazon SQS is always <code>alias/aws/sqs</code>, the alias of a custom CMK can, for example, be <code>alias/<i>MyAlias</i>
    /// </code>.
    /// For more examples, see <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">KeyId</a> in the <i>Key Management Service API Reference</i>.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>KmsDataKeyReusePeriodSeconds</code> – The length of time, in seconds, for which Amazon SQS can reuse a <a href="https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys">data key</a> to encrypt
    /// or decrypt messages before calling KMS again. An integer representing seconds, between 60 seconds (1 minute) and 86,400 seconds (24 hours). Default: 300 (5 minutes). A shorter time period provides better security
    /// but results in more calls to KMS which might incur charges after Free Tier. For more information, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-how-does-the-data-key-reuse-period-work">How Does the Data Key Reuse Period Work?</a>.
    /// </p>
    /// </li>
    /// </ul>
    /// <p>The following attribute applies only to <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO (first-in-first-out) queues</a>:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>ContentBasedDeduplication</code> – Enables content-based deduplication. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues-exactly-once-processing.html">Exactly-once processing</a> in the
    /// <i>Amazon SQS Developer Guide</i>. Note the following:
    /// </p>
    /// <ul>
    /// <li>
    /// <p>Every message must have a unique <code>MessageDeduplicationId</code>.</p>
    /// <ul>
    /// <li>
    /// <p>You may provide a <code>MessageDeduplicationId</code> explicitly.</p>
    /// </li>
    /// <li>
    /// <p>If you aren't able to provide a <code>MessageDeduplicationId</code> and you enable <code>ContentBasedDeduplication</code> for your queue,
    /// Amazon SQS uses a SHA-256 hash to generate the <code>MessageDeduplicationId</code> using the body of the message (but not the attributes of the message).
    /// </p>
    /// </li>
    /// <li>
    /// <p>If you don't provide a <code>MessageDeduplicationId</code> and the queue doesn't have <code>ContentBasedDeduplication</code> set,
    /// the action fails with an error.</p>
    /// </li>
    /// <li>
    /// <p>If the queue has <code>ContentBasedDeduplication</code> set, your <code>MessageDeduplicationId</code> overrides the generated one.</p>
    /// </li>
    /// </ul>
    /// </li>
    /// <li>
    /// <p>When <code>ContentBasedDeduplication</code> is in effect, messages with identical content sent within the deduplication interval are treated as duplicates
    /// and only one copy of the message is delivered.</p>
    /// </li>
    /// <li>
    /// <p>If you send one message with <code>ContentBasedDeduplication</code> enabled and then another message with a <code>MessageDeduplicationId</code> that is the same
    /// as the one generated for the first <code>MessageDeduplicationId</code>, the two messages are treated as duplicates and only one copy of the message is delivered.
    /// </p>
    /// </li>
    /// </ul>  
    /// </li>
    /// </ul>
    /// <p>The following attributes apply only to
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/high-throughput-fifo.html">high throughput
    /// for FIFO queues</a>:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>DeduplicationScope</code> – Specifies whether message deduplication occurs at the
    /// message group or queue level. Valid values are <code>messageGroup</code> and <code>queue</code>.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>FifoThroughputLimit</code> – Specifies whether the FIFO queue throughput
    /// quota applies to the entire queue or per message group. Valid values are <code>perQueue</code> and <code>perMessageGroupId</code>.
    /// The <code>perMessageGroupId</code> value is allowed only when the value for <code>DeduplicationScope</code> is <code>messageGroup</code>.</p>
    /// </li>
    /// </ul>
    /// <p>To enable high throughput for FIFO queues, do the following:</p>
    /// <ul>
    /// <li>
    /// <p>Set <code>DeduplicationScope</code> to <code>messageGroup</code>.</p>
    /// </li>
    /// <li>
    /// <p>Set <code>FifoThroughputLimit</code> to <code>perMessageGroupId</code>.</p>
    /// </li>
    /// </ul>
    /// <p>If you set these attributes to anything other than the values shown for enabling high
    /// throughput, normal throughput is in effect and deduplication occurs as specified.</p>
    /// <p>For information on throughput quotas,
    /// see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/quotas-messages.html">Quotas related to messages</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    pub attributes: std::option::Option<
        std::collections::HashMap<crate::model::QueueAttributeName, std::string::String>,
    >,
}
impl std::fmt::Debug for SetQueueAttributesInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SetQueueAttributesInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("attributes", &self.attributes);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SendMessageBatchInput {
    /// <p>The URL of the Amazon SQS queue to which batched messages are sent.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>A list of <code>
    /// <a>SendMessageBatchRequestEntry</a>
    /// </code> items.</p>
    pub entries: std::option::Option<std::vec::Vec<crate::model::SendMessageBatchRequestEntry>>,
}
impl std::fmt::Debug for SendMessageBatchInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SendMessageBatchInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("entries", &self.entries);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SendMessageInput {
    /// <p>The URL of the Amazon SQS queue to which a message is sent.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>The message to send. The minimum size is one character. The maximum size is 256 KB.</p>
    /// <important>
    /// <p>A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed:</p>
    /// <p>
    /// <code>#x9</code> | <code>#xA</code> | <code>#xD</code> | <code>#x20</code> to <code>#xD7FF</code> | <code>#xE000</code> to <code>#xFFFD</code> | <code>#x10000</code> to <code>#x10FFFF</code>
    /// </p>
    /// <p>Any characters not included in this list will be rejected. For more information, see the <a href="http://www.w3.org/TR/REC-xml/#charsets">W3C specification for characters</a>.</p>
    /// </important>
    pub message_body: std::option::Option<std::string::String>,
    /// <p>
    /// The length of time, in seconds, for which to delay a specific message. Valid values: 0 to 900. Maximum: 15 minutes. Messages with a positive <code>DelaySeconds</code> value become available for processing after the delay period is finished.
    /// If you don't specify a value, the default value for the queue applies.
    /// </p>
    /// <note>
    /// <p>When you set <code>FifoQueue</code>, you can't set <code>DelaySeconds</code> per message. You can set this parameter only on a queue level.</p>
    /// </note>
    pub delay_seconds: i32,
    /// <p>Each message attribute consists of a <code>Name</code>, <code>Type</code>,
    /// and <code>Value</code>. For more information, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html#sqs-message-attributes">Amazon SQS
    /// message attributes</a> in the <i>Amazon SQS Developer Guide</i>.</p>
    pub message_attributes: std::option::Option<
        std::collections::HashMap<std::string::String, crate::model::MessageAttributeValue>,
    >,
    /// <p>The message system attribute to send. Each message system attribute consists of a <code>Name</code>, <code>Type</code>, and <code>Value</code>.</p>
    /// <important>
    /// <ul>
    /// <li>
    /// <p>Currently, the only supported message system attribute is <code>AWSTraceHeader</code>.
    /// Its type must be <code>String</code> and its value must be a correctly formatted
    /// X-Ray trace header string.</p>
    /// </li>
    /// <li>
    /// <p>The size of a message system attribute doesn't count towards the total size of a message.</p>
    /// </li>
    /// </ul>
    /// </important>
    pub message_system_attributes: std::option::Option<
        std::collections::HashMap<
            crate::model::MessageSystemAttributeNameForSends,
            crate::model::MessageSystemAttributeValue,
        >,
    >,
    /// <p>This parameter applies only to FIFO (first-in-first-out) queues.</p>
    /// <p>The token used for deduplication of sent messages. If a message with a particular <code>MessageDeduplicationId</code> is sent successfully, any messages sent with the same <code>MessageDeduplicationId</code>
    /// are accepted successfully but aren't delivered during the 5-minute deduplication interval. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues-exactly-once-processing.html">
    /// Exactly-once processing</a> in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <ul>
    /// <li>
    /// <p>Every message must have a unique <code>MessageDeduplicationId</code>,</p>
    /// <ul>
    /// <li>
    /// <p>You may provide a <code>MessageDeduplicationId</code> explicitly.</p>
    /// </li>
    /// <li>
    /// <p>If you aren't able to provide a <code>MessageDeduplicationId</code> and you enable <code>ContentBasedDeduplication</code> for your queue,
    /// Amazon SQS uses a SHA-256 hash to generate the <code>MessageDeduplicationId</code> using the body of the message (but not the attributes of the message).
    /// </p>
    /// </li>
    /// <li>
    /// <p>If you don't provide a <code>MessageDeduplicationId</code> and the queue doesn't have <code>ContentBasedDeduplication</code> set,
    /// the action fails with an error.</p>
    /// </li>
    /// <li>
    /// <p>If the queue has <code>ContentBasedDeduplication</code> set, your <code>MessageDeduplicationId</code> overrides the generated one.</p>
    /// </li>
    /// </ul>
    /// </li>
    /// <li>
    /// <p>When <code>ContentBasedDeduplication</code> is in effect, messages with identical content sent within the deduplication interval are treated as duplicates
    /// and only one copy of the message is delivered.</p>
    /// </li>
    /// <li>
    /// <p>If you send one message with <code>ContentBasedDeduplication</code> enabled and then another message with a <code>MessageDeduplicationId</code> that is the same
    /// as the one generated for the first <code>MessageDeduplicationId</code>, the two messages are treated as duplicates and only one copy of the message is delivered.
    /// </p>
    /// </li>
    /// </ul>
    /// <note>
    /// <p>The <code>MessageDeduplicationId</code> is available to the consumer of the
    /// message (this can be useful for troubleshooting delivery issues).</p>
    /// <p>If a message is sent successfully but the acknowledgement is lost and the message is resent with the same
    /// <code>MessageDeduplicationId</code> after the deduplication interval, Amazon SQS can't detect duplicate messages.</p>
    /// <p>Amazon SQS continues to keep track of the message deduplication ID even after the message is received and deleted.</p>
    /// </note>
    /// <p>The maximum length of <code>MessageDeduplicationId</code> is 128 characters. <code>MessageDeduplicationId</code> can contain alphanumeric characters (<code>a-z</code>, <code>A-Z</code>, <code>0-9</code>) and
    /// punctuation (<code>!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~</code>).</p>
    /// <p>For best practices of using <code>MessageDeduplicationId</code>, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-messagededuplicationid-property.html">Using the MessageDeduplicationId Property</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    pub message_deduplication_id: std::option::Option<std::string::String>,
    /// <p>This parameter applies only to FIFO (first-in-first-out) queues.</p>
    /// <p>The tag that specifies that a message belongs to a specific message group. Messages
    /// that belong to the same message group are processed in a FIFO manner (however,
    /// messages in different message groups might be processed out of order). To interleave
    /// multiple ordered streams within a single queue, use <code>MessageGroupId</code> values
    /// (for example, session data for multiple users). In this scenario, multiple consumers can
    /// process the queue, but the session data of each user is processed in a FIFO
    /// fashion.</p>
    /// <ul>
    /// <li>
    /// <p>You must associate a non-empty <code>MessageGroupId</code> with a message. If you don't provide a <code>MessageGroupId</code>, the action fails.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ReceiveMessage</code> might return messages with multiple <code>MessageGroupId</code> values. For each <code>MessageGroupId</code>, the messages are sorted by time sent. The caller can't
    /// specify a <code>MessageGroupId</code>.</p>
    /// </li>
    /// </ul>
    /// <p>The length of <code>MessageGroupId</code> is 128 characters. Valid values: alphanumeric characters and punctuation <code>(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)</code>.</p>
    /// <p>For best practices of using <code>MessageGroupId</code>, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-messagegroupid-property.html">Using the MessageGroupId Property</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <important>
    /// <p>
    /// <code>MessageGroupId</code> is required for FIFO queues. You can't use it for Standard queues.</p>
    /// </important>
    pub message_group_id: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for SendMessageInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SendMessageInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("message_body", &self.message_body);
        formatter.field("delay_seconds", &self.delay_seconds);
        formatter.field("message_attributes", &self.message_attributes);
        formatter.field("message_system_attributes", &self.message_system_attributes);
        formatter.field("message_deduplication_id", &self.message_deduplication_id);
        formatter.field("message_group_id", &self.message_group_id);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RemovePermissionInput {
    /// <p>The URL of the Amazon SQS queue from which permissions are removed.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>The identification of the permission to remove. This is the label added using the <code>
    /// <a>AddPermission</a>
    /// </code> action.</p>
    pub label: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for RemovePermissionInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RemovePermissionInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("label", &self.label);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ReceiveMessageInput {
    /// <p>The URL of the Amazon SQS queue from which messages are received.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>A list of attributes that need to be returned along with each message. These attributes
    /// include:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>All</code> – Returns all values.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ApproximateFirstReceiveTimestamp</code> – Returns the time the message was first received from the queue (<a href="http://en.wikipedia.org/wiki/Unix_time">epoch time</a> in milliseconds).</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ApproximateReceiveCount</code> – Returns the number of times a message has been received across all queues but not deleted.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>AWSTraceHeader</code> – Returns the X-Ray trace header string.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>SenderId</code>
    /// </p>
    /// <ul>
    /// <li>
    /// <p>For an IAM user, returns the IAM user ID, for example <code>ABCDEFGHI1JKLMNOPQ23R</code>.</p>
    /// </li>
    /// <li>
    /// <p>For an IAM role, returns the IAM role ID, for example <code>ABCDE1F2GH3I4JK5LMNOP:i-a123b456</code>.</p>
    /// </li>
    /// </ul>
    /// </li>
    /// <li>
    /// <p>
    /// <code>SentTimestamp</code> – Returns the time the message was sent to the queue (<a href="http://en.wikipedia.org/wiki/Unix_time">epoch time</a> in milliseconds).</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MessageDeduplicationId</code> – Returns the value provided by the
    /// producer that calls the <code>
    /// <a>SendMessage</a>
    /// </code>
    /// action.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MessageGroupId</code> – Returns the value provided by the producer that
    /// calls the <code>
    /// <a>SendMessage</a>
    /// </code> action. Messages with the
    /// same <code>MessageGroupId</code> are returned in sequence.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>SequenceNumber</code> – Returns the value provided by Amazon SQS.</p>
    /// </li>
    /// </ul>
    pub attribute_names: std::option::Option<std::vec::Vec<crate::model::QueueAttributeName>>,
    /// <p>The name of the message attribute, where <i>N</i> is the index.</p>
    /// <ul>
    /// <li>
    /// <p>The name can contain alphanumeric characters and the underscore (<code>_</code>), hyphen (<code>-</code>), and period (<code>.</code>).</p>
    /// </li>
    /// <li>
    /// <p>The name is case-sensitive and must be unique among all attribute names for the message.</p>
    /// </li>
    /// <li>
    /// <p>The name must not start with AWS-reserved prefixes such as <code>AWS.</code> or <code>Amazon.</code> (or any casing variants).</p>
    /// </li>
    /// <li>
    /// <p>The name must not start or end with a period (<code>.</code>), and it should not have periods in succession (<code>..</code>).</p>
    /// </li>
    /// <li>
    /// <p>The name can be up to 256 characters long.</p>
    /// </li>
    /// </ul>
    /// <p>When using <code>ReceiveMessage</code>, you can send a list of attribute names to receive, or you can return all of the attributes by specifying <code>All</code> or <code>.*</code> in your request.
    /// You can also use all message attributes starting with a prefix, for example <code>bar.*</code>.</p>
    pub message_attribute_names: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The maximum number of messages to return. Amazon SQS never returns more messages than this value (however, fewer messages might be returned). Valid values: 1 to 10. Default: 1.</p>
    pub max_number_of_messages: i32,
    /// <p>The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a <code>ReceiveMessage</code> request.</p>
    pub visibility_timeout: i32,
    /// <p>The duration (in seconds) for which the call waits for a message to arrive in the queue before returning. If a message is available, the call returns sooner than <code>WaitTimeSeconds</code>.
    /// If no messages are available and the wait time expires, the call returns successfully with an empty list of messages.</p>
    /// <important>
    /// <p>To avoid HTTP errors, ensure that the HTTP response timeout for <code>ReceiveMessage</code>
    /// requests is longer than the <code>WaitTimeSeconds</code> parameter. For example,
    /// with the Java SDK, you can set HTTP transport settings using the <a href="https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html"> NettyNioAsyncHttpClient</a> for asynchronous clients, or the <a href="https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html"> ApacheHttpClient</a> for synchronous clients. </p>
    /// </important>
    pub wait_time_seconds: i32,
    /// <p>This parameter applies only to FIFO (first-in-first-out) queues.</p>
    /// <p>The token used for deduplication of <code>ReceiveMessage</code> calls. If a networking issue occurs after a <code>ReceiveMessage</code> action, and instead of a response you receive a generic error,
    /// it is possible to retry the same action with an identical <code>ReceiveRequestAttemptId</code> to retrieve the same set of messages, even if their visibility timeout has not yet expired.</p>
    /// <ul>
    /// <li>
    /// <p>You can use <code>ReceiveRequestAttemptId</code> only for 5 minutes after a <code>ReceiveMessage</code> action.</p>
    /// </li>
    /// <li>
    /// <p>When you set <code>FifoQueue</code>, a caller of the <code>ReceiveMessage</code> action can provide a <code>ReceiveRequestAttemptId</code> explicitly.</p>
    /// </li>
    /// <li>
    /// <p>If a caller of the <code>ReceiveMessage</code> action doesn't provide a <code>ReceiveRequestAttemptId</code>, Amazon SQS generates a <code>ReceiveRequestAttemptId</code>.</p>
    /// </li>
    /// <li>
    /// <p>It is possible to retry the <code>ReceiveMessage</code> action with the same <code>ReceiveRequestAttemptId</code> if none of the messages have been modified (deleted or had their visibility changes).</p>
    /// </li>
    /// <li>
    /// <p>During a visibility timeout, subsequent calls with the same <code>ReceiveRequestAttemptId</code> return the same messages and receipt handles. If a retry occurs within the deduplication interval,
    /// it resets the visibility timeout. For more information, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html">Visibility Timeout</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <important>
    /// <p>If a caller of the <code>ReceiveMessage</code> action still processes
    /// messages when the visibility timeout expires and messages become visible,
    /// another worker consuming from the same queue can receive the same messages
    /// and therefore process duplicates. Also, if a consumer whose message
    /// processing time is longer than the visibility timeout tries to delete the
    /// processed messages, the action fails with an error.</p>
    /// <p>To mitigate this effect, ensure that your application observes a safe threshold before the visibility timeout expires and extend the visibility timeout as necessary.</p>
    /// </important>
    /// </li>
    /// <li>
    /// <p>While messages with a particular <code>MessageGroupId</code> are invisible, no more messages belonging to the same <code>MessageGroupId</code> are returned until the visibility timeout expires. You can still receive
    /// messages with another <code>MessageGroupId</code> as long as it is also visible.</p>
    /// </li>
    /// <li>
    /// <p>If a caller of <code>ReceiveMessage</code> can't track the <code>ReceiveRequestAttemptId</code>, no retries work until the original visibility timeout expires. As a result, delays might occur but
    /// the messages in the queue remain in a strict order.</p>
    /// </li>
    /// </ul>
    /// <p>The maximum length of <code>ReceiveRequestAttemptId</code> is 128 characters. <code>ReceiveRequestAttemptId</code> can contain alphanumeric characters (<code>a-z</code>, <code>A-Z</code>, <code>0-9</code>) and
    /// punctuation (<code>!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~</code>).</p>
    /// <p>For best practices of using <code>ReceiveRequestAttemptId</code>, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-receiverequestattemptid-request-parameter.html">Using the ReceiveRequestAttemptId Request Parameter</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    pub receive_request_attempt_id: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ReceiveMessageInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ReceiveMessageInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("attribute_names", &self.attribute_names);
        formatter.field("message_attribute_names", &self.message_attribute_names);
        formatter.field("max_number_of_messages", &self.max_number_of_messages);
        formatter.field("visibility_timeout", &self.visibility_timeout);
        formatter.field("wait_time_seconds", &self.wait_time_seconds);
        formatter.field(
            "receive_request_attempt_id",
            &self.receive_request_attempt_id,
        );
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PurgeQueueInput {
    /// <p>The URL of the queue from which the <code>PurgeQueue</code> action deletes messages.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for PurgeQueueInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PurgeQueueInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListQueueTagsInput {
    /// <p>The URL of the queue.</p>
    pub queue_url: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListQueueTagsInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListQueueTagsInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListQueuesInput {
    /// <p>A string to use for filtering the list results. Only those queues whose name begins with the specified string are returned.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_name_prefix: std::option::Option<std::string::String>,
    /// <p>Pagination token to request the next set of results.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>Maximum number of results to include in the response. Value range is 1 to 1000.
    /// You must set <code>MaxResults</code> to receive a value for <code>NextToken</code> in the response.</p>
    pub max_results: std::option::Option<i32>,
}
impl std::fmt::Debug for ListQueuesInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListQueuesInput");
        formatter.field("queue_name_prefix", &self.queue_name_prefix);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDeadLetterSourceQueuesInput {
    /// <p>The URL of a dead-letter queue.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>Pagination token to request the next set of results.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>Maximum number of results to include in the response. Value range is 1 to 1000.
    /// You must set <code>MaxResults</code> to receive a value for <code>NextToken</code> in the response.</p>
    pub max_results: std::option::Option<i32>,
}
impl std::fmt::Debug for ListDeadLetterSourceQueuesInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDeadLetterSourceQueuesInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("next_token", &self.next_token);
        formatter.field("max_results", &self.max_results);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetQueueUrlInput {
    /// <p>The name of the queue whose URL must be fetched. Maximum 80 characters. Valid values: alphanumeric characters, hyphens (<code>-</code>), and underscores (<code>_</code>).</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_name: std::option::Option<std::string::String>,
    /// <p>The account ID of the account that created the queue.</p>
    pub queue_owner_aws_account_id: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for GetQueueUrlInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetQueueUrlInput");
        formatter.field("queue_name", &self.queue_name);
        formatter.field(
            "queue_owner_aws_account_id",
            &self.queue_owner_aws_account_id,
        );
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetQueueAttributesInput {
    /// <p>The URL of the Amazon SQS queue whose attribute information is retrieved.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>A list of attributes for which to retrieve information.</p>
    /// <p>The <code>AttributeName.N</code> parameter is optional, but if you don't specify values for this parameter,
    /// the request returns empty results.</p>
    /// <note>
    /// <p>In the future, new attributes might be added. If you write code that calls this action, we recommend that you structure your code so that it can handle new attributes gracefully.</p>
    /// </note>
    /// <p>The following attributes are supported:</p>
    /// <important>
    /// <p>The <code>ApproximateNumberOfMessagesDelayed</code>, <code>ApproximateNumberOfMessagesNotVisible</code>,
    /// and <code>ApproximateNumberOfMessagesVisible</code> metrics may not achieve consistency
    /// until at least 1 minute after the producers stop sending messages. This period is required for
    /// the queue metadata to reach eventual consistency. </p>
    /// </important>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>All</code> – Returns all values. </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ApproximateNumberOfMessages</code> – Returns the approximate number of
    /// messages available for retrieval from the queue.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ApproximateNumberOfMessagesDelayed</code> – Returns the approximate number
    /// of messages in the queue that are delayed and not available for reading
    /// immediately. This can happen when the queue is configured as a delay queue or
    /// when a message has been sent with a delay parameter.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ApproximateNumberOfMessagesNotVisible</code> – Returns the approximate
    /// number of messages that are in flight. Messages are considered to be
    /// <i>in flight</i> if they have been sent to a client but have
    /// not yet been deleted or have not yet reached the end of their visibility window. </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>CreatedTimestamp</code> – Returns the time when the queue was created in
    /// seconds (<a href="http://en.wikipedia.org/wiki/Unix_time">epoch
    /// time</a>).</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>DelaySeconds</code> – Returns the default delay on the queue in
    /// seconds.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>LastModifiedTimestamp</code> – Returns the time when the queue was last
    /// changed in seconds (<a href="http://en.wikipedia.org/wiki/Unix_time">epoch
    /// time</a>).</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MaximumMessageSize</code> – Returns the limit of how many bytes a message
    /// can contain before Amazon SQS rejects it.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MessageRetentionPeriod</code> – Returns the length of time, in seconds,
    /// for which Amazon SQS retains a message.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>Policy</code> – Returns the policy of the queue.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>QueueArn</code> – Returns the Amazon resource name (ARN) of the
    /// queue.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ReceiveMessageWaitTimeSeconds</code> – Returns the length of time, in
    /// seconds, for which the <code>ReceiveMessage</code> action waits for a message to
    /// arrive. </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>RedrivePolicy</code> – The string that includes the parameters for the dead-letter queue functionality
    /// of the source queue as a JSON object. For more information about the redrive policy and dead-letter queues, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html">Using Amazon SQS Dead-Letter Queues</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>deadLetterTargetArn</code> – The Amazon Resource Name (ARN) of the dead-letter queue to which Amazon SQS moves messages after the value of <code>maxReceiveCount</code> is exceeded.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>maxReceiveCount</code> – The number of times a message is delivered to the source queue before being moved to the dead-letter queue.
    /// When the <code>ReceiveCount</code> for a message exceeds the <code>maxReceiveCount</code> for a queue, Amazon SQS moves the message to the dead-letter-queue.</p>
    /// </li>
    /// </ul>
    /// </li>
    /// <li>
    /// <p>
    /// <code>VisibilityTimeout</code> – Returns the visibility timeout for the queue. For more information about the visibility timeout, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html">Visibility Timeout</a> in the <i>Amazon SQS Developer Guide</i>.
    /// </p>
    /// </li>
    /// </ul>
    /// <p>The following attributes apply only to <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html">server-side-encryption</a>:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>KmsMasterKeyId</code> – Returns the ID of an Amazon Web Services managed customer master key (CMK) for Amazon SQS or a custom CMK. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-sse-key-terms">Key Terms</a>.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>KmsDataKeyReusePeriodSeconds</code> – Returns the length of time, in seconds, for which Amazon SQS can reuse a data key to encrypt or decrypt messages before calling KMS again.
    /// For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-how-does-the-data-key-reuse-period-work">How Does the Data Key Reuse Period Work?</a>.
    /// </p>
    /// </li>
    /// </ul>
    /// <p>The following attributes apply only to <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO (first-in-first-out) queues</a>:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>FifoQueue</code> – Returns information about whether the queue is FIFO. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues-understanding-logic.html">FIFO queue logic</a> in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <note>
    /// <p>To determine whether a queue is <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO</a>, you can check whether <code>QueueName</code> ends with the <code>.fifo</code> suffix.</p>
    /// </note>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ContentBasedDeduplication</code> – Returns whether content-based deduplication is enabled for the queue. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues-exactly-once-processing.html">Exactly-once processing</a> in the <i>Amazon SQS Developer Guide</i>.
    /// </p>
    /// </li>
    /// </ul>
    /// <p>The following attributes apply only to
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/high-throughput-fifo.html">high throughput
    /// for FIFO queues</a>:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>DeduplicationScope</code> – Specifies whether message deduplication occurs at the
    /// message group or queue level. Valid values are <code>messageGroup</code> and <code>queue</code>.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>FifoThroughputLimit</code> – Specifies whether the FIFO queue throughput
    /// quota applies to the entire queue or per message group. Valid values are <code>perQueue</code> and <code>perMessageGroupId</code>.
    /// The <code>perMessageGroupId</code> value is allowed only when the value for <code>DeduplicationScope</code> is <code>messageGroup</code>.</p>
    /// </li>
    /// </ul>
    /// <p>To enable high throughput for FIFO queues, do the following:</p>
    /// <ul>
    /// <li>
    /// <p>Set <code>DeduplicationScope</code> to <code>messageGroup</code>.</p>
    /// </li>
    /// <li>
    /// <p>Set <code>FifoThroughputLimit</code> to <code>perMessageGroupId</code>.</p>
    /// </li>
    /// </ul>
    /// <p>If you set these attributes to anything other than the values shown for enabling high
    /// throughput, normal throughput is in effect and deduplication occurs as specified.</p>
    /// <p>For information on throughput quotas,
    /// see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/quotas-messages.html">Quotas related to messages</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    pub attribute_names: std::option::Option<std::vec::Vec<crate::model::QueueAttributeName>>,
}
impl std::fmt::Debug for GetQueueAttributesInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetQueueAttributesInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("attribute_names", &self.attribute_names);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteQueueInput {
    /// <p>The URL of the Amazon SQS queue to delete.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DeleteQueueInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteQueueInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteMessageBatchInput {
    /// <p>The URL of the Amazon SQS queue from which messages are deleted.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>A list of receipt handles for the messages to be deleted.</p>
    pub entries: std::option::Option<std::vec::Vec<crate::model::DeleteMessageBatchRequestEntry>>,
}
impl std::fmt::Debug for DeleteMessageBatchInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteMessageBatchInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("entries", &self.entries);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteMessageInput {
    /// <p>The URL of the Amazon SQS queue from which messages are deleted.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>The receipt handle associated with the message to delete.</p>
    pub receipt_handle: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DeleteMessageInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteMessageInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("receipt_handle", &self.receipt_handle);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateQueueInput {
    /// <p>The name of the new queue. The following limits apply to this name:</p>
    /// <ul>
    /// <li>
    /// <p>A queue name can have up to 80 characters.</p>               
    /// </li>
    /// <li>
    /// <p>Valid values: alphanumeric characters, hyphens (<code>-</code>), and underscores (<code>_</code>).</p>
    /// </li>
    /// <li>
    /// <p>A FIFO queue name must end with the <code>.fifo</code> suffix.</p>
    /// </li>
    /// </ul>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_name: std::option::Option<std::string::String>,
    /// <p>Add cost allocation tags to the specified Amazon SQS queue. For an overview, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html">Tagging
    /// Your Amazon SQS Queues</a> in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <p>When you use queue tags, keep the following guidelines in mind:</p>
    /// <ul>
    /// <li>
    /// <p>Adding more than 50 tags to a queue isn't recommended.</p>
    /// </li>
    /// <li>
    /// <p>Tags don't have any semantic meaning. Amazon SQS interprets tags as character strings.</p>
    /// </li>
    /// <li>
    /// <p>Tags are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>A new tag with a key identical to that of an existing tag overwrites the existing tag.</p>
    /// </li>
    /// </ul>
    /// <p>For a full list of tag restrictions, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-limits.html#limits-queues">Quotas related to queues</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <note>
    /// <p>To be able to tag a queue on creation, you must have the
    /// <code>sqs:CreateQueue</code> and <code>sqs:TagQueue</code> permissions.</p>
    /// <p>Cross-account permissions don't apply to this action. For more information,
    /// see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name">Grant
    /// cross-account permissions to a role and a user name</a> in the <i>Amazon SQS Developer Guide</i>.</p>
    /// </note>
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
    /// <p>A map of attributes with their corresponding values.</p>
    /// <p>The following lists the names, descriptions, and values of the special request parameters that the <code>CreateQueue</code> action uses:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>DelaySeconds</code> – The length of time, in seconds, for which the delivery of all messages in the queue is delayed. Valid values: An integer from 0 to 900 seconds (15 minutes). Default: 0.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MaximumMessageSize</code> – The limit of how many bytes a message can contain before Amazon SQS rejects it. Valid values: An integer from 1,024 bytes (1 KiB) to 262,144 bytes (256 KiB). Default: 262,144 (256 KiB).
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MessageRetentionPeriod</code> – The length of time, in seconds, for which Amazon SQS retains a message. Valid values: An integer from 60 seconds (1 minute) to 1,209,600 seconds (14 days). Default: 345,600 (4 days).
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>Policy</code> – The queue's policy. A valid Amazon Web Services policy. For more information about policy structure, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/PoliciesOverview.html">Overview of Amazon Web Services IAM Policies</a> in the <i>Amazon IAM User Guide</i>.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ReceiveMessageWaitTimeSeconds</code> – The length of time, in seconds, for which a <code>
    /// <a>ReceiveMessage</a>
    /// </code> action waits for a message to arrive. Valid values: An integer from 0 to 20 (seconds). Default: 0.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>RedrivePolicy</code> – The string that includes the parameters for the dead-letter queue functionality
    /// of the source queue as a JSON object. For more information about the redrive policy and dead-letter queues, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html">Using Amazon SQS Dead-Letter Queues</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>deadLetterTargetArn</code> – The Amazon Resource Name (ARN) of the dead-letter queue to which Amazon SQS moves messages after the value of <code>maxReceiveCount</code> is exceeded.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>maxReceiveCount</code> – The number of times a message is delivered to the source queue before being moved to the dead-letter queue.
    /// When the <code>ReceiveCount</code> for a message exceeds the <code>maxReceiveCount</code> for a queue, Amazon SQS moves the message to the dead-letter-queue.</p>
    /// </li>
    /// </ul>
    /// <note>
    /// <p>The dead-letter queue of a FIFO queue must also be a FIFO queue. Similarly, the dead-letter queue of a standard queue must also be a standard queue.</p>
    /// </note>
    /// </li>
    /// <li>
    /// <p>
    /// <code>VisibilityTimeout</code> – The visibility timeout for the queue, in seconds. Valid values: An integer from 0 to 43,200 (12 hours). Default: 30. For more information about the visibility timeout, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html">Visibility Timeout</a> in the <i>Amazon SQS Developer Guide</i>.</p>
    /// </li>
    /// </ul>
    /// <p>The following attributes apply only to <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html">server-side-encryption</a>:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>KmsMasterKeyId</code> – The ID of an Amazon Web Services managed customer master key (CMK) for Amazon SQS or a custom CMK. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-sse-key-terms">Key Terms</a>.
    /// While the alias of the Amazon Web Services managed CMK for Amazon SQS is always <code>alias/aws/sqs</code>, the alias of a custom CMK can, for example, be <code>alias/<i>MyAlias</i>
    /// </code>.
    /// For more examples, see <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">KeyId</a> in the <i>Key Management Service API Reference</i>.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>KmsDataKeyReusePeriodSeconds</code> – The length of time, in seconds, for which Amazon SQS can reuse a <a href="https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys">data key</a> to encrypt
    /// or decrypt messages before calling KMS again. An integer representing seconds, between 60 seconds (1 minute) and 86,400 seconds (24 hours). Default: 300 (5 minutes). A shorter time period provides better security
    /// but results in more calls to KMS which might incur charges after Free Tier. For more information, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-how-does-the-data-key-reuse-period-work">How Does the Data Key Reuse Period Work?</a>.
    /// </p>
    /// </li>
    /// </ul>
    /// <p>The following attributes apply only to <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO (first-in-first-out) queues</a>:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>FifoQueue</code> – Designates a queue as FIFO. Valid values are <code>true</code> and <code>false</code>. If you don't specify the <code>FifoQueue</code> attribute, Amazon SQS creates a standard queue.
    /// You can provide this attribute only during queue creation. You can't change it for an existing queue.
    /// When you set this attribute, you must also provide the <code>MessageGroupId</code> for your messages explicitly.</p>
    /// <p>For more information, see
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues-understanding-logic.html">FIFO queue logic</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>ContentBasedDeduplication</code> – Enables content-based deduplication. Valid values are <code>true</code> and <code>false</code>. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues-exactly-once-processing.html">Exactly-once processing</a> in the
    /// <i>Amazon SQS Developer Guide</i>. Note the following:
    /// </p>
    /// <ul>
    /// <li>
    /// <p>Every message must have a unique <code>MessageDeduplicationId</code>.</p>
    /// <ul>
    /// <li>
    /// <p>You may provide a <code>MessageDeduplicationId</code> explicitly.</p>
    /// </li>
    /// <li>
    /// <p>If you aren't able to provide a <code>MessageDeduplicationId</code> and you enable <code>ContentBasedDeduplication</code> for your queue,
    /// Amazon SQS uses a SHA-256 hash to generate the <code>MessageDeduplicationId</code> using the body of the message (but not the attributes of the message).
    /// </p>
    /// </li>
    /// <li>
    /// <p>If you don't provide a <code>MessageDeduplicationId</code> and the queue doesn't have <code>ContentBasedDeduplication</code> set,
    /// the action fails with an error.</p>
    /// </li>
    /// <li>
    /// <p>If the queue has <code>ContentBasedDeduplication</code> set, your <code>MessageDeduplicationId</code> overrides the generated one.</p>
    /// </li>
    /// </ul>
    /// </li>
    /// <li>
    /// <p>When <code>ContentBasedDeduplication</code> is in effect, messages with identical content sent within the deduplication interval are treated as duplicates
    /// and only one copy of the message is delivered.</p>
    /// </li>
    /// <li>
    /// <p>If you send one message with <code>ContentBasedDeduplication</code> enabled and then another message with a <code>MessageDeduplicationId</code> that is the same
    /// as the one generated for the first <code>MessageDeduplicationId</code>, the two messages are treated as duplicates and only one copy of the message is delivered.
    /// </p>
    /// </li>
    /// </ul>
    /// </li>
    /// </ul>  
    /// <p>The following attributes apply only to
    /// <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/high-throughput-fifo.html">high throughput
    /// for FIFO queues</a>:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>DeduplicationScope</code> – Specifies whether message deduplication occurs at the
    /// message group or queue level. Valid values are <code>messageGroup</code> and <code>queue</code>.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>FifoThroughputLimit</code> – Specifies whether the FIFO queue throughput
    /// quota applies to the entire queue or per message group. Valid values are <code>perQueue</code> and <code>perMessageGroupId</code>.
    /// The <code>perMessageGroupId</code> value is allowed only when the value for <code>DeduplicationScope</code> is <code>messageGroup</code>.</p>
    /// </li>
    /// </ul>
    /// <p>To enable high throughput for FIFO queues, do the following:</p>
    /// <ul>
    /// <li>
    /// <p>Set <code>DeduplicationScope</code> to <code>messageGroup</code>.</p>
    /// </li>
    /// <li>
    /// <p>Set <code>FifoThroughputLimit</code> to <code>perMessageGroupId</code>.</p>
    /// </li>
    /// </ul>
    /// <p>If you set these attributes to anything other than the values shown for enabling high
    /// throughput, normal throughput is in effect and deduplication occurs as specified.</p>
    /// <p>For information on throughput quotas,
    /// see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/quotas-messages.html">Quotas related to messages</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    pub attributes: std::option::Option<
        std::collections::HashMap<crate::model::QueueAttributeName, std::string::String>,
    >,
}
impl std::fmt::Debug for CreateQueueInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateQueueInput");
        formatter.field("queue_name", &self.queue_name);
        formatter.field("tags", &self.tags);
        formatter.field("attributes", &self.attributes);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ChangeMessageVisibilityBatchInput {
    /// <p>The URL of the Amazon SQS queue whose messages' visibility is changed.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>A list of receipt handles of the messages for which the visibility timeout must be changed.</p>
    pub entries:
        std::option::Option<std::vec::Vec<crate::model::ChangeMessageVisibilityBatchRequestEntry>>,
}
impl std::fmt::Debug for ChangeMessageVisibilityBatchInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ChangeMessageVisibilityBatchInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("entries", &self.entries);
        formatter.finish()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ChangeMessageVisibilityInput {
    /// <p>The URL of the Amazon SQS queue whose message's visibility is changed.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>The receipt handle associated with the message whose visibility timeout is changed. This parameter is returned by the <code>
    /// <a>ReceiveMessage</a>
    /// </code> action.</p>
    pub receipt_handle: std::option::Option<std::string::String>,
    /// <p>The new value for the message's visibility timeout (in seconds). Values range: <code>0</code> to <code>43200</code>. Maximum: 12 hours.</p>
    pub visibility_timeout: i32,
}
impl std::fmt::Debug for ChangeMessageVisibilityInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ChangeMessageVisibilityInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("receipt_handle", &self.receipt_handle);
        formatter.field("visibility_timeout", &self.visibility_timeout);
        formatter.finish()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AddPermissionInput {
    /// <p>The URL of the Amazon SQS queue to which permissions are added.</p>
    /// <p>Queue URLs and names are case-sensitive.</p>
    pub queue_url: std::option::Option<std::string::String>,
    /// <p>The unique identification of the permission you're setting (for example, <code>AliceSendMessage</code>). Maximum 80 characters. Allowed characters include alphanumeric characters, hyphens (<code>-</code>), and underscores (<code>_</code>).</p>
    pub label: std::option::Option<std::string::String>,
    /// <p>The account numbers of the <a href="https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#P">principals</a> who are to receive
    /// permission. For information about locating the account identification, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-making-api-requests.html#sqs-api-request-authentication">Your Amazon Web Services Identifiers</a> in the <i>Amazon SQS Developer
    /// Guide</i>.</p>
    pub aws_account_ids: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The action the client wants to allow for the specified principal. Valid values: the name of any action or <code>*</code>.</p>
    /// <p>For more information about these actions, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-overview-of-managing-access.html">Overview of Managing Access Permissions to Your Amazon Simple Queue Service Resource</a>
    /// in the <i>Amazon SQS Developer Guide</i>.</p>
    /// <p>Specifying <code>SendMessage</code>, <code>DeleteMessage</code>, or <code>ChangeMessageVisibility</code> for <code>ActionName.n</code> also grants permissions for the corresponding batch versions of those actions: <code>SendMessageBatch</code>,
    /// <code>DeleteMessageBatch</code>, and <code>ChangeMessageVisibilityBatch</code>.</p>
    pub actions: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl std::fmt::Debug for AddPermissionInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("AddPermissionInput");
        formatter.field("queue_url", &self.queue_url);
        formatter.field("label", &self.label);
        formatter.field("aws_account_ids", &self.aws_account_ids);
        formatter.field("actions", &self.actions);
        formatter.finish()
    }
}
