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

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

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

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

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

impl<C, M, R> Client<C, M, R> {
    pub fn with_config(client: smithy_client::Client<C, M, R>, conf: crate::Config) -> Self {
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }

    pub fn conf(&self) -> &crate::Config {
        &self.handle.conf
    }
}
impl<C, M, R> Client<C, M, R>
where
    C: smithy_client::bounds::SmithyConnector,
    M: smithy_client::bounds::SmithyMiddleware<C>,
    R: smithy_client::retry::NewRequestPolicy,
{
    pub fn associate_service_quota_template(
        &self,
    ) -> fluent_builders::AssociateServiceQuotaTemplate<C, M, R> {
        fluent_builders::AssociateServiceQuotaTemplate::new(self.handle.clone())
    }
    pub fn delete_service_quota_increase_request_from_template(
        &self,
    ) -> fluent_builders::DeleteServiceQuotaIncreaseRequestFromTemplate<C, M, R> {
        fluent_builders::DeleteServiceQuotaIncreaseRequestFromTemplate::new(self.handle.clone())
    }
    pub fn disassociate_service_quota_template(
        &self,
    ) -> fluent_builders::DisassociateServiceQuotaTemplate<C, M, R> {
        fluent_builders::DisassociateServiceQuotaTemplate::new(self.handle.clone())
    }
    pub fn get_association_for_service_quota_template(
        &self,
    ) -> fluent_builders::GetAssociationForServiceQuotaTemplate<C, M, R> {
        fluent_builders::GetAssociationForServiceQuotaTemplate::new(self.handle.clone())
    }
    pub fn get_aws_default_service_quota(
        &self,
    ) -> fluent_builders::GetAWSDefaultServiceQuota<C, M, R> {
        fluent_builders::GetAWSDefaultServiceQuota::new(self.handle.clone())
    }
    pub fn get_requested_service_quota_change(
        &self,
    ) -> fluent_builders::GetRequestedServiceQuotaChange<C, M, R> {
        fluent_builders::GetRequestedServiceQuotaChange::new(self.handle.clone())
    }
    pub fn get_service_quota(&self) -> fluent_builders::GetServiceQuota<C, M, R> {
        fluent_builders::GetServiceQuota::new(self.handle.clone())
    }
    pub fn get_service_quota_increase_request_from_template(
        &self,
    ) -> fluent_builders::GetServiceQuotaIncreaseRequestFromTemplate<C, M, R> {
        fluent_builders::GetServiceQuotaIncreaseRequestFromTemplate::new(self.handle.clone())
    }
    pub fn list_aws_default_service_quotas(
        &self,
    ) -> fluent_builders::ListAWSDefaultServiceQuotas<C, M, R> {
        fluent_builders::ListAWSDefaultServiceQuotas::new(self.handle.clone())
    }
    pub fn list_requested_service_quota_change_history(
        &self,
    ) -> fluent_builders::ListRequestedServiceQuotaChangeHistory<C, M, R> {
        fluent_builders::ListRequestedServiceQuotaChangeHistory::new(self.handle.clone())
    }
    pub fn list_requested_service_quota_change_history_by_quota(
        &self,
    ) -> fluent_builders::ListRequestedServiceQuotaChangeHistoryByQuota<C, M, R> {
        fluent_builders::ListRequestedServiceQuotaChangeHistoryByQuota::new(self.handle.clone())
    }
    pub fn list_service_quota_increase_requests_in_template(
        &self,
    ) -> fluent_builders::ListServiceQuotaIncreaseRequestsInTemplate<C, M, R> {
        fluent_builders::ListServiceQuotaIncreaseRequestsInTemplate::new(self.handle.clone())
    }
    pub fn list_service_quotas(&self) -> fluent_builders::ListServiceQuotas<C, M, R> {
        fluent_builders::ListServiceQuotas::new(self.handle.clone())
    }
    pub fn list_services(&self) -> fluent_builders::ListServices<C, M, R> {
        fluent_builders::ListServices::new(self.handle.clone())
    }
    pub fn list_tags_for_resource(&self) -> fluent_builders::ListTagsForResource<C, M, R> {
        fluent_builders::ListTagsForResource::new(self.handle.clone())
    }
    pub fn put_service_quota_increase_request_into_template(
        &self,
    ) -> fluent_builders::PutServiceQuotaIncreaseRequestIntoTemplate<C, M, R> {
        fluent_builders::PutServiceQuotaIncreaseRequestIntoTemplate::new(self.handle.clone())
    }
    pub fn request_service_quota_increase(
        &self,
    ) -> fluent_builders::RequestServiceQuotaIncrease<C, M, R> {
        fluent_builders::RequestServiceQuotaIncrease::new(self.handle.clone())
    }
    pub fn tag_resource(&self) -> fluent_builders::TagResource<C, M, R> {
        fluent_builders::TagResource::new(self.handle.clone())
    }
    pub fn untag_resource(&self) -> fluent_builders::UntagResource<C, M, R> {
        fluent_builders::UntagResource::new(self.handle.clone())
    }
}
pub mod fluent_builders {
    #[derive(std::fmt::Debug)]
    pub struct AssociateServiceQuotaTemplate<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::associate_service_quota_template_input::Builder,
    }
    impl<C, M, R> AssociateServiceQuotaTemplate<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::AssociateServiceQuotaTemplateOutput,
            smithy_http::result::SdkError<crate::error::AssociateServiceQuotaTemplateError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::AssociateServiceQuotaTemplateInputOperationOutputAlias,
                crate::output::AssociateServiceQuotaTemplateOutput,
                crate::error::AssociateServiceQuotaTemplateError,
                crate::input::AssociateServiceQuotaTemplateInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct DeleteServiceQuotaIncreaseRequestFromTemplate<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::delete_service_quota_increase_request_from_template_input::Builder,
    }
    impl<C, M, R> DeleteServiceQuotaIncreaseRequestFromTemplate<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
                                pub async fn send(self) -> std::result::Result<crate::output::DeleteServiceQuotaIncreaseRequestFromTemplateOutput, smithy_http::result::SdkError<crate::error::DeleteServiceQuotaIncreaseRequestFromTemplateError>>
                                where
                                    R::Policy: smithy_client::bounds::SmithyRetryPolicy<crate::input::DeleteServiceQuotaIncreaseRequestFromTemplateInputOperationOutputAlias,
                                    crate::output::DeleteServiceQuotaIncreaseRequestFromTemplateOutput,
                                    crate::error::DeleteServiceQuotaIncreaseRequestFromTemplateError,
                                    crate::input::DeleteServiceQuotaIncreaseRequestFromTemplateInputOperationRetryAlias>,
                                {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The quota identifier.</p>
        pub fn quota_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.quota_code(inp);
            self
        }
        pub fn set_quota_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_quota_code(input);
            self
        }
        /// <p>The AWS Region.</p>
        pub fn aws_region(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.aws_region(inp);
            self
        }
        pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_aws_region(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct DisassociateServiceQuotaTemplate<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::disassociate_service_quota_template_input::Builder,
    }
    impl<C, M, R> DisassociateServiceQuotaTemplate<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DisassociateServiceQuotaTemplateOutput,
            smithy_http::result::SdkError<crate::error::DisassociateServiceQuotaTemplateError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DisassociateServiceQuotaTemplateInputOperationOutputAlias,
                crate::output::DisassociateServiceQuotaTemplateOutput,
                crate::error::DisassociateServiceQuotaTemplateError,
                crate::input::DisassociateServiceQuotaTemplateInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct GetAssociationForServiceQuotaTemplate<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_association_for_service_quota_template_input::Builder,
    }
    impl<C, M, R> GetAssociationForServiceQuotaTemplate<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetAssociationForServiceQuotaTemplateOutput,
            smithy_http::result::SdkError<crate::error::GetAssociationForServiceQuotaTemplateError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetAssociationForServiceQuotaTemplateInputOperationOutputAlias,
                crate::output::GetAssociationForServiceQuotaTemplateOutput,
                crate::error::GetAssociationForServiceQuotaTemplateError,
                crate::input::GetAssociationForServiceQuotaTemplateInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct GetAWSDefaultServiceQuota<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_aws_default_service_quota_input::Builder,
    }
    impl<C, M, R> GetAWSDefaultServiceQuota<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetAwsDefaultServiceQuotaOutput,
            smithy_http::result::SdkError<crate::error::GetAWSDefaultServiceQuotaError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetAwsDefaultServiceQuotaInputOperationOutputAlias,
                crate::output::GetAwsDefaultServiceQuotaOutput,
                crate::error::GetAWSDefaultServiceQuotaError,
                crate::input::GetAwsDefaultServiceQuotaInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The quota identifier.</p>
        pub fn quota_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.quota_code(inp);
            self
        }
        pub fn set_quota_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_quota_code(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct GetRequestedServiceQuotaChange<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_requested_service_quota_change_input::Builder,
    }
    impl<C, M, R> GetRequestedServiceQuotaChange<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetRequestedServiceQuotaChangeOutput,
            smithy_http::result::SdkError<crate::error::GetRequestedServiceQuotaChangeError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetRequestedServiceQuotaChangeInputOperationOutputAlias,
                crate::output::GetRequestedServiceQuotaChangeOutput,
                crate::error::GetRequestedServiceQuotaChangeError,
                crate::input::GetRequestedServiceQuotaChangeInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The ID of the quota increase request.</p>
        pub fn request_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.request_id(inp);
            self
        }
        pub fn set_request_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_request_id(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct GetServiceQuota<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_service_quota_input::Builder,
    }
    impl<C, M, R> GetServiceQuota<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetServiceQuotaOutput,
            smithy_http::result::SdkError<crate::error::GetServiceQuotaError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetServiceQuotaInputOperationOutputAlias,
                crate::output::GetServiceQuotaOutput,
                crate::error::GetServiceQuotaError,
                crate::input::GetServiceQuotaInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The quota identifier.</p>
        pub fn quota_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.quota_code(inp);
            self
        }
        pub fn set_quota_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_quota_code(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct GetServiceQuotaIncreaseRequestFromTemplate<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_service_quota_increase_request_from_template_input::Builder,
    }
    impl<C, M, R> GetServiceQuotaIncreaseRequestFromTemplate<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetServiceQuotaIncreaseRequestFromTemplateOutput,
            smithy_http::result::SdkError<
                crate::error::GetServiceQuotaIncreaseRequestFromTemplateError,
            >,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetServiceQuotaIncreaseRequestFromTemplateInputOperationOutputAlias,
                crate::output::GetServiceQuotaIncreaseRequestFromTemplateOutput,
                crate::error::GetServiceQuotaIncreaseRequestFromTemplateError,
                crate::input::GetServiceQuotaIncreaseRequestFromTemplateInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The quota identifier.</p>
        pub fn quota_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.quota_code(inp);
            self
        }
        pub fn set_quota_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_quota_code(input);
            self
        }
        /// <p>The AWS Region.</p>
        pub fn aws_region(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.aws_region(inp);
            self
        }
        pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_aws_region(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct ListAWSDefaultServiceQuotas<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_aws_default_service_quotas_input::Builder,
    }
    impl<C, M, R> ListAWSDefaultServiceQuotas<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListAwsDefaultServiceQuotasOutput,
            smithy_http::result::SdkError<crate::error::ListAWSDefaultServiceQuotasError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListAwsDefaultServiceQuotasInputOperationOutputAlias,
                crate::output::ListAwsDefaultServiceQuotasOutput,
                crate::error::ListAWSDefaultServiceQuotasError,
                crate::input::ListAwsDefaultServiceQuotasInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The token for the next page of results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum number of results to return with a single call. To retrieve the remaining
        /// results, if any, make another call with the token returned from this call.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct ListRequestedServiceQuotaChangeHistory<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_requested_service_quota_change_history_input::Builder,
    }
    impl<C, M, R> ListRequestedServiceQuotaChangeHistory<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListRequestedServiceQuotaChangeHistoryOutput,
            smithy_http::result::SdkError<
                crate::error::ListRequestedServiceQuotaChangeHistoryError,
            >,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListRequestedServiceQuotaChangeHistoryInputOperationOutputAlias,
                crate::output::ListRequestedServiceQuotaChangeHistoryOutput,
                crate::error::ListRequestedServiceQuotaChangeHistoryError,
                crate::input::ListRequestedServiceQuotaChangeHistoryInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The status of the quota increase request.</p>
        pub fn status(mut self, inp: crate::model::RequestStatus) -> Self {
            self.inner = self.inner.status(inp);
            self
        }
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::RequestStatus>,
        ) -> Self {
            self.inner = self.inner.set_status(input);
            self
        }
        /// <p>The token for the next page of results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum number of results to return with a single call. To retrieve the remaining
        /// results, if any, make another call with the token returned from this call.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct ListRequestedServiceQuotaChangeHistoryByQuota<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_requested_service_quota_change_history_by_quota_input::Builder,
    }
    impl<C, M, R> ListRequestedServiceQuotaChangeHistoryByQuota<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
                                pub async fn send(self) -> std::result::Result<crate::output::ListRequestedServiceQuotaChangeHistoryByQuotaOutput, smithy_http::result::SdkError<crate::error::ListRequestedServiceQuotaChangeHistoryByQuotaError>>
                                where
                                    R::Policy: smithy_client::bounds::SmithyRetryPolicy<crate::input::ListRequestedServiceQuotaChangeHistoryByQuotaInputOperationOutputAlias,
                                    crate::output::ListRequestedServiceQuotaChangeHistoryByQuotaOutput,
                                    crate::error::ListRequestedServiceQuotaChangeHistoryByQuotaError,
                                    crate::input::ListRequestedServiceQuotaChangeHistoryByQuotaInputOperationRetryAlias>,
                                {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The quota identifier.</p>
        pub fn quota_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.quota_code(inp);
            self
        }
        pub fn set_quota_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_quota_code(input);
            self
        }
        /// <p>The status value of the quota increase request.</p>
        pub fn status(mut self, inp: crate::model::RequestStatus) -> Self {
            self.inner = self.inner.status(inp);
            self
        }
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::RequestStatus>,
        ) -> Self {
            self.inner = self.inner.set_status(input);
            self
        }
        /// <p>The token for the next page of results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum number of results to return with a single call. To retrieve the remaining
        /// results, if any, make another call with the token returned from this call.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct ListServiceQuotaIncreaseRequestsInTemplate<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_service_quota_increase_requests_in_template_input::Builder,
    }
    impl<C, M, R> ListServiceQuotaIncreaseRequestsInTemplate<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListServiceQuotaIncreaseRequestsInTemplateOutput,
            smithy_http::result::SdkError<
                crate::error::ListServiceQuotaIncreaseRequestsInTemplateError,
            >,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListServiceQuotaIncreaseRequestsInTemplateInputOperationOutputAlias,
                crate::output::ListServiceQuotaIncreaseRequestsInTemplateOutput,
                crate::error::ListServiceQuotaIncreaseRequestsInTemplateError,
                crate::input::ListServiceQuotaIncreaseRequestsInTemplateInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The AWS Region.</p>
        pub fn aws_region(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.aws_region(inp);
            self
        }
        pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_aws_region(input);
            self
        }
        /// <p>The token for the next page of results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum number of results to return with a single call. To retrieve the remaining
        /// results, if any, make another call with the token returned from this call.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct ListServiceQuotas<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_service_quotas_input::Builder,
    }
    impl<C, M, R> ListServiceQuotas<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListServiceQuotasOutput,
            smithy_http::result::SdkError<crate::error::ListServiceQuotasError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListServiceQuotasInputOperationOutputAlias,
                crate::output::ListServiceQuotasOutput,
                crate::error::ListServiceQuotasError,
                crate::input::ListServiceQuotasInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The token for the next page of results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum number of results to return with a single call. To retrieve the remaining
        /// results, if any, make another call with the token returned from this call.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct ListServices<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_services_input::Builder,
    }
    impl<C, M, R> ListServices<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListServicesOutput,
            smithy_http::result::SdkError<crate::error::ListServicesError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListServicesInputOperationOutputAlias,
                crate::output::ListServicesOutput,
                crate::error::ListServicesError,
                crate::input::ListServicesInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The token for the next page of results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum number of results to return with a single call. To retrieve the remaining
        /// results, if any, make another call with the token returned from this call.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct ListTagsForResource<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_tags_for_resource_input::Builder,
    }
    impl<C, M, R> ListTagsForResource<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListTagsForResourceOutput,
            smithy_http::result::SdkError<crate::error::ListTagsForResourceError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListTagsForResourceInputOperationOutputAlias,
                crate::output::ListTagsForResourceOutput,
                crate::error::ListTagsForResourceError,
                crate::input::ListTagsForResourceInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) for the applied quota for which you want to list tags. You
        /// can get this information by using the Service Quotas console, or by listing the quotas using the
        /// <a href="https://docs.aws.amazon.com/cli/latest/reference/service-quotas/list-service-quotas.html">list-service-quotas</a> AWS CLI command or the <a href="https://docs.aws.amazon.com/servicequotas/2019-06-24/apireference/API_ListServiceQuotas.html">ListServiceQuotas</a> AWS API operation.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct PutServiceQuotaIncreaseRequestIntoTemplate<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::put_service_quota_increase_request_into_template_input::Builder,
    }
    impl<C, M, R> PutServiceQuotaIncreaseRequestIntoTemplate<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::PutServiceQuotaIncreaseRequestIntoTemplateOutput,
            smithy_http::result::SdkError<
                crate::error::PutServiceQuotaIncreaseRequestIntoTemplateError,
            >,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::PutServiceQuotaIncreaseRequestIntoTemplateInputOperationOutputAlias,
                crate::output::PutServiceQuotaIncreaseRequestIntoTemplateOutput,
                crate::error::PutServiceQuotaIncreaseRequestIntoTemplateError,
                crate::input::PutServiceQuotaIncreaseRequestIntoTemplateInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The quota identifier.</p>
        pub fn quota_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.quota_code(inp);
            self
        }
        pub fn set_quota_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_quota_code(input);
            self
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The AWS Region.</p>
        pub fn aws_region(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.aws_region(inp);
            self
        }
        pub fn set_aws_region(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_aws_region(input);
            self
        }
        /// <p>The new, increased value for the quota.</p>
        pub fn desired_value(mut self, inp: f64) -> Self {
            self.inner = self.inner.desired_value(inp);
            self
        }
        pub fn set_desired_value(mut self, input: std::option::Option<f64>) -> Self {
            self.inner = self.inner.set_desired_value(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct RequestServiceQuotaIncrease<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::request_service_quota_increase_input::Builder,
    }
    impl<C, M, R> RequestServiceQuotaIncrease<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::RequestServiceQuotaIncreaseOutput,
            smithy_http::result::SdkError<crate::error::RequestServiceQuotaIncreaseError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::RequestServiceQuotaIncreaseInputOperationOutputAlias,
                crate::output::RequestServiceQuotaIncreaseOutput,
                crate::error::RequestServiceQuotaIncreaseError,
                crate::input::RequestServiceQuotaIncreaseInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The service identifier.</p>
        pub fn service_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.service_code(inp);
            self
        }
        pub fn set_service_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_service_code(input);
            self
        }
        /// <p>The quota identifier.</p>
        pub fn quota_code(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.quota_code(inp);
            self
        }
        pub fn set_quota_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_quota_code(input);
            self
        }
        /// <p>The new, increased value for the quota.</p>
        pub fn desired_value(mut self, inp: f64) -> Self {
            self.inner = self.inner.desired_value(inp);
            self
        }
        pub fn set_desired_value(mut self, input: std::option::Option<f64>) -> Self {
            self.inner = self.inner.set_desired_value(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct TagResource<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::tag_resource_input::Builder,
    }
    impl<C, M, R> TagResource<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::TagResourceOutput,
            smithy_http::result::SdkError<crate::error::TagResourceError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::TagResourceInputOperationOutputAlias,
                crate::output::TagResourceOutput,
                crate::error::TagResourceError,
                crate::input::TagResourceInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) for the applied quota. You can get this information by
        /// using the Service Quotas console, or by listing the quotas using the <a href="https://docs.aws.amazon.com/cli/latest/reference/service-quotas/list-service-quotas.html">list-service-quotas</a> AWS CLI command or the <a href="https://docs.aws.amazon.com/servicequotas/2019-06-24/apireference/API_ListServiceQuotas.html">ListServiceQuotas</a> AWS API operation.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
        /// Appends an item to `Tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        /// <p>The tags that you want to add to the resource.</p>
        pub fn tags(mut self, inp: impl Into<crate::model::Tag>) -> Self {
            self.inner = self.inner.tags(inp);
            self
        }
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    #[derive(std::fmt::Debug)]
    pub struct UntagResource<
        C = smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::untag_resource_input::Builder,
    }
    impl<C, M, R> UntagResource<C, M, R>
    where
        C: smithy_client::bounds::SmithyConnector,
        M: smithy_client::bounds::SmithyMiddleware<C>,
        R: smithy_client::retry::NewRequestPolicy,
    {
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UntagResourceOutput,
            smithy_http::result::SdkError<crate::error::UntagResourceError>,
        >
        where
            R::Policy: smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UntagResourceInputOperationOutputAlias,
                crate::output::UntagResourceOutput,
                crate::error::UntagResourceError,
                crate::input::UntagResourceInputOperationRetryAlias,
            >,
        {
            let input = self
                .inner
                .build()
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            let op = input
                .make_operation(&self.handle.conf)
                .map_err(|err| smithy_http::result::SdkError::ConstructionFailure(err.into()))?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) for the applied quota that you want to untag. You can get
        /// this information by using the Service Quotas console, or by listing the quotas using the <a href="https://docs.aws.amazon.com/cli/latest/reference/service-quotas/list-service-quotas.html">list-service-quotas</a> AWS CLI command or the <a href="https://docs.aws.amazon.com/servicequotas/2019-06-24/apireference/API_ListServiceQuotas.html">ListServiceQuotas</a> AWS API operation.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
        /// Appends an item to `TagKeys`.
        ///
        /// To override the contents of this collection use [`set_tag_keys`](Self::set_tag_keys).
        /// <p>The keys of the tags that you want to remove from the resource.</p>
        pub fn tag_keys(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.tag_keys(inp);
            self
        }
        pub fn set_tag_keys(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_tag_keys(input);
            self
        }
    }
}
impl<C> Client<C, aws_hyper::AwsMiddleware, smithy_client::retry::Standard> {
    pub fn from_conf_conn(conf: crate::Config, conn: C) -> Self {
        let client = aws_hyper::Client::new(conn);
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}
impl
    Client<
        smithy_client::erase::DynConnector,
        aws_hyper::AwsMiddleware,
        smithy_client::retry::Standard,
    >
{
    #[cfg(any(feature = "rustls", feature = "native-tls"))]
    pub fn new(config: &aws_types::config::Config) -> Self {
        Self::from_conf(config.into())
    }

    #[cfg(any(feature = "rustls", feature = "native-tls"))]
    pub fn from_conf(conf: crate::Config) -> Self {
        let client = aws_hyper::Client::https();
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}
