// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
use std::fmt::Write;

/// See [`CreateAs2ConnectionInput`](crate::input::CreateAs2ConnectionInput).
pub mod create_as2_connection_input {

    /// A builder for [`CreateAs2ConnectionInput`](crate::input::CreateAs2ConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) local_as2_id: std::option::Option<std::string::String>,
        pub(crate) partner_as2_id: std::option::Option<std::string::String>,
        pub(crate) inbound_settings: std::option::Option<crate::model::As2InboundFields>,
        pub(crate) outbound_settings: std::option::Option<crate::model::As2OutboundFields>,
        pub(crate) local_signing: std::option::Option<crate::model::As2LocalCertificate>,
        pub(crate) local_encryption: std::option::Option<crate::model::As2LocalCertificate>,
        pub(crate) partner_signing: std::option::Option<crate::model::As2PartnerCertificate>,
        pub(crate) partner_encryption: std::option::Option<crate::model::As2PartnerCertificate>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The name of the connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_as2_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.local_as2_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_as2_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.local_as2_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_as2_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partner_as2_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_as2_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partner_as2_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_settings(mut self, input: crate::model::As2InboundFields) -> Self {
            self.inbound_settings = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_settings(
            mut self,
            input: std::option::Option<crate::model::As2InboundFields>,
        ) -> Self {
            self.inbound_settings = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_settings(mut self, input: crate::model::As2OutboundFields) -> Self {
            self.outbound_settings = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_settings(
            mut self,
            input: std::option::Option<crate::model::As2OutboundFields>,
        ) -> Self {
            self.outbound_settings = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_signing(mut self, input: crate::model::As2LocalCertificate) -> Self {
            self.local_signing = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_signing(
            mut self,
            input: std::option::Option<crate::model::As2LocalCertificate>,
        ) -> Self {
            self.local_signing = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_encryption(mut self, input: crate::model::As2LocalCertificate) -> Self {
            self.local_encryption = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_encryption(
            mut self,
            input: std::option::Option<crate::model::As2LocalCertificate>,
        ) -> Self {
            self.local_encryption = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_signing(mut self, input: crate::model::As2PartnerCertificate) -> Self {
            self.partner_signing = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_signing(
            mut self,
            input: std::option::Option<crate::model::As2PartnerCertificate>,
        ) -> Self {
            self.partner_signing = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_encryption(mut self, input: crate::model::As2PartnerCertificate) -> Self {
            self.partner_encryption = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_encryption(
            mut self,
            input: std::option::Option<crate::model::As2PartnerCertificate>,
        ) -> Self {
            self.partner_encryption = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateAs2ConnectionInput`](crate::input::CreateAs2ConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateAs2ConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateAs2ConnectionInput {
                name: self.name,
                local_as2_id: self.local_as2_id,
                partner_as2_id: self.partner_as2_id,
                inbound_settings: self.inbound_settings,
                outbound_settings: self.outbound_settings,
                local_signing: self.local_signing,
                local_encryption: self.local_encryption,
                partner_signing: self.partner_signing,
                partner_encryption: self.partner_encryption,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl CreateAs2ConnectionInput {
    /// Consumes the builder and constructs an Operation<[`CreateAs2Connection`](crate::operation::CreateAs2Connection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateAs2Connection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateAs2ConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_1 = &_input.partnership_id;
                let input_1 = input_1.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_1,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/as2",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateAs2ConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_as2_connection(&self)?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateAs2Connection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateAs2Connection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateAs2ConnectionInput`](crate::input::CreateAs2ConnectionInput).
    pub fn builder() -> crate::input::create_as2_connection_input::Builder {
        crate::input::create_as2_connection_input::Builder::default()
    }
}

/// See [`CreateBucketConnectionInput`](crate::input::CreateBucketConnectionInput).
pub mod create_bucket_connection_input {

    /// A builder for [`CreateBucketConnectionInput`](crate::input::CreateBucketConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) inbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) outbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) delete_inbound_files_on_receipt: std::option::Option<bool>,
        pub(crate) bucket_name: std::option::Option<std::string::String>,
        pub(crate) parent_directory: std::option::Option<std::string::String>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The name of the connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.inbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.outbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn delete_inbound_files_on_receipt(mut self, input: bool) -> Self {
            self.delete_inbound_files_on_receipt = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_delete_inbound_files_on_receipt(
            mut self,
            input: std::option::Option<bool>,
        ) -> Self {
            self.delete_inbound_files_on_receipt = input;
            self
        }
        /// The name of the stedi bucket
        pub fn bucket_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.bucket_name = Some(input.into());
            self
        }
        /// The name of the stedi bucket
        pub fn set_bucket_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.bucket_name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn parent_directory(mut self, input: impl Into<std::string::String>) -> Self {
            self.parent_directory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_parent_directory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.parent_directory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateBucketConnectionInput`](crate::input::CreateBucketConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateBucketConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateBucketConnectionInput {
                name: self.name,
                inbound_subdirectory: self.inbound_subdirectory,
                outbound_subdirectory: self.outbound_subdirectory,
                delete_inbound_files_on_receipt: self.delete_inbound_files_on_receipt,
                bucket_name: self.bucket_name,
                parent_directory: self.parent_directory,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl CreateBucketConnectionInput {
    /// Consumes the builder and constructs an Operation<[`CreateBucketConnection`](crate::operation::CreateBucketConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateBucketConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateBucketConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_2 = &_input.partnership_id;
                let input_2 = input_2.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_2,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/buckets",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateBucketConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_bucket_connection(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateBucketConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateBucketConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateBucketConnectionInput`](crate::input::CreateBucketConnectionInput).
    pub fn builder() -> crate::input::create_bucket_connection_input::Builder {
        crate::input::create_bucket_connection_input::Builder::default()
    }
}

/// See [`CreateGlobalConnectionInput`](crate::input::CreateGlobalConnectionInput).
pub mod create_global_connection_input {

    /// A builder for [`CreateGlobalConnectionInput`](crate::input::CreateGlobalConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) bucket_name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The name of the global connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the global connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// The name of the stedi bucket
        pub fn bucket_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.bucket_name = Some(input.into());
            self
        }
        /// The name of the stedi bucket
        pub fn set_bucket_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.bucket_name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateGlobalConnectionInput`](crate::input::CreateGlobalConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateGlobalConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateGlobalConnectionInput {
                name: self.name,
                bucket_name: self.bucket_name,
            })
        }
    }
}
impl CreateGlobalConnectionInput {
    /// Consumes the builder and constructs an Operation<[`CreateGlobalConnection`](crate::operation::CreateGlobalConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateGlobalConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateGlobalConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/global-connections").expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateGlobalConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_global_connection(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateGlobalConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateGlobalConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateGlobalConnectionInput`](crate::input::CreateGlobalConnectionInput).
    pub fn builder() -> crate::input::create_global_connection_input::Builder {
        crate::input::create_global_connection_input::Builder::default()
    }
}

/// See [`CreateInboundX12TransactionSettingsInput`](crate::input::CreateInboundX12TransactionSettingsInput).
pub mod create_inbound_x12_transaction_settings_input {

    /// A builder for [`CreateInboundX12TransactionSettingsInput`](crate::input::CreateInboundX12TransactionSettingsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) release: std::option::Option<std::string::String>,
        pub(crate) transaction_set_identifier: std::option::Option<std::string::String>,
        pub(crate) guide_id: std::option::Option<std::string::String>,
        pub(crate) enable_fragments: std::option::Option<bool>,
        pub(crate) fragment_size: std::option::Option<i32>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn release(mut self, input: impl Into<std::string::String>) -> Self {
            self.release = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_release(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.release = input;
            self
        }
        /// The X12 transaction set code, can include industry identifier.
        pub fn transaction_set_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.transaction_set_identifier = Some(input.into());
            self
        }
        /// The X12 transaction set code, can include industry identifier.
        pub fn set_transaction_set_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.transaction_set_identifier = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn guide_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.guide_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_guide_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.guide_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enable_fragments(mut self, input: bool) -> Self {
            self.enable_fragments = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enable_fragments(mut self, input: std::option::Option<bool>) -> Self {
            self.enable_fragments = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn fragment_size(mut self, input: i32) -> Self {
            self.fragment_size = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_fragment_size(mut self, input: std::option::Option<i32>) -> Self {
            self.fragment_size = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateInboundX12TransactionSettingsInput`](crate::input::CreateInboundX12TransactionSettingsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateInboundX12TransactionSettingsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateInboundX12TransactionSettingsInput {
                release: self.release,
                transaction_set_identifier: self.transaction_set_identifier,
                guide_id: self.guide_id,
                enable_fragments: self.enable_fragments,
                fragment_size: self.fragment_size,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl CreateInboundX12TransactionSettingsInput {
    /// Consumes the builder and constructs an Operation<[`CreateInboundX12TransactionSettings`](crate::operation::CreateInboundX12TransactionSettings)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateInboundX12TransactionSettings,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateInboundX12TransactionSettingsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_3 = &_input.partnership_id;
                let input_3 = input_3.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_3,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/inbound-transactions",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateInboundX12TransactionSettingsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_inbound_x12_transaction_settings(&self)?
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateInboundX12TransactionSettings::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateInboundX12TransactionSettings",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateInboundX12TransactionSettingsInput`](crate::input::CreateInboundX12TransactionSettingsInput).
    pub fn builder() -> crate::input::create_inbound_x12_transaction_settings_input::Builder {
        crate::input::create_inbound_x12_transaction_settings_input::Builder::default()
    }
}

/// See [`CreateOutboundX12TransactionSettingsInput`](crate::input::CreateOutboundX12TransactionSettingsInput).
pub mod create_outbound_x12_transaction_settings_input {

    /// A builder for [`CreateOutboundX12TransactionSettingsInput`](crate::input::CreateOutboundX12TransactionSettingsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) release: std::option::Option<std::string::String>,
        pub(crate) transaction_set_identifier: std::option::Option<std::string::String>,
        pub(crate) guide_id: std::option::Option<std::string::String>,
        pub(crate) local_application_id: std::option::Option<std::string::String>,
        pub(crate) partner_application_id: std::option::Option<std::string::String>,
        pub(crate) connection: std::option::Option<crate::model::OutboundConnection>,
        pub(crate) outbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn release(mut self, input: impl Into<std::string::String>) -> Self {
            self.release = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_release(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.release = input;
            self
        }
        /// The X12 transaction set code, can include industry identifier.
        pub fn transaction_set_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.transaction_set_identifier = Some(input.into());
            self
        }
        /// The X12 transaction set code, can include industry identifier.
        pub fn set_transaction_set_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.transaction_set_identifier = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn guide_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.guide_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_guide_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.guide_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_application_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.local_application_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_application_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.local_application_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_application_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partner_application_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_application_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partner_application_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn connection(mut self, input: crate::model::OutboundConnection) -> Self {
            self.connection = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_connection(
            mut self,
            input: std::option::Option<crate::model::OutboundConnection>,
        ) -> Self {
            self.connection = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_x12_transaction_settings_id(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.outbound_x12_transaction_settings_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_x12_transaction_settings_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_x12_transaction_settings_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateOutboundX12TransactionSettingsInput`](crate::input::CreateOutboundX12TransactionSettingsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateOutboundX12TransactionSettingsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateOutboundX12TransactionSettingsInput {
                release: self.release,
                transaction_set_identifier: self.transaction_set_identifier,
                guide_id: self.guide_id,
                local_application_id: self.local_application_id,
                partner_application_id: self.partner_application_id,
                connection: self.connection,
                outbound_x12_transaction_settings_id: self.outbound_x12_transaction_settings_id,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl CreateOutboundX12TransactionSettingsInput {
    /// Consumes the builder and constructs an Operation<[`CreateOutboundX12TransactionSettings`](crate::operation::CreateOutboundX12TransactionSettings)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateOutboundX12TransactionSettings,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateOutboundX12TransactionSettingsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_4 = &_input.partnership_id;
                let input_4 = input_4.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_4,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/outbound-transactions",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateOutboundX12TransactionSettingsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_outbound_x12_transaction_settings(&self)?
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateOutboundX12TransactionSettings::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateOutboundX12TransactionSettings",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateOutboundX12TransactionSettingsInput`](crate::input::CreateOutboundX12TransactionSettingsInput).
    pub fn builder() -> crate::input::create_outbound_x12_transaction_settings_input::Builder {
        crate::input::create_outbound_x12_transaction_settings_input::Builder::default()
    }
}

/// See [`CreateRemoteFtpConnectionInput`](crate::input::CreateRemoteFtpConnectionInput).
pub mod create_remote_ftp_connection_input {

    /// A builder for [`CreateRemoteFtpConnectionInput`](crate::input::CreateRemoteFtpConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) inbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) outbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) root_directory: std::option::Option<std::string::String>,
        pub(crate) host: std::option::Option<std::string::String>,
        pub(crate) username: std::option::Option<std::string::String>,
        pub(crate) port: std::option::Option<i32>,
        pub(crate) delete_after_retrieval: std::option::Option<bool>,
        pub(crate) ignore_file_timestamps: std::option::Option<bool>,
        pub(crate) enable_polling: std::option::Option<bool>,
        pub(crate) polling_interval: std::option::Option<i32>,
        pub(crate) polling_interval_unit: std::option::Option<crate::model::FtpIntervalUnit>,
        pub(crate) last_poll_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) retries: std::option::Option<i32>,
        pub(crate) ready_timeout: std::option::Option<i32>,
        pub(crate) timeout: std::option::Option<i32>,
        pub(crate) algorithms: std::option::Option<crate::model::RemoteFtpAlgorithms>,
        pub(crate) password: std::option::Option<std::string::String>,
        pub(crate) private_key: std::option::Option<std::string::String>,
        pub(crate) passphrase: std::option::Option<std::string::String>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The name of the connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.inbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.outbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_subdirectory = input;
            self
        }
        /// The root directory for this FTP connection
        pub fn root_directory(mut self, input: impl Into<std::string::String>) -> Self {
            self.root_directory = Some(input.into());
            self
        }
        /// The root directory for this FTP connection
        pub fn set_root_directory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.root_directory = input;
            self
        }
        /// The endpoint associated with the FTP connection
        pub fn host(mut self, input: impl Into<std::string::String>) -> Self {
            self.host = Some(input.into());
            self
        }
        /// The endpoint associated with the FTP connection
        pub fn set_host(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.host = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn username(mut self, input: impl Into<std::string::String>) -> Self {
            self.username = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_username(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.username = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn port(mut self, input: i32) -> Self {
            self.port = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_port(mut self, input: std::option::Option<i32>) -> Self {
            self.port = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn delete_after_retrieval(mut self, input: bool) -> Self {
            self.delete_after_retrieval = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_delete_after_retrieval(mut self, input: std::option::Option<bool>) -> Self {
            self.delete_after_retrieval = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn ignore_file_timestamps(mut self, input: bool) -> Self {
            self.ignore_file_timestamps = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_ignore_file_timestamps(mut self, input: std::option::Option<bool>) -> Self {
            self.ignore_file_timestamps = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enable_polling(mut self, input: bool) -> Self {
            self.enable_polling = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enable_polling(mut self, input: std::option::Option<bool>) -> Self {
            self.enable_polling = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn polling_interval(mut self, input: i32) -> Self {
            self.polling_interval = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_polling_interval(mut self, input: std::option::Option<i32>) -> Self {
            self.polling_interval = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn polling_interval_unit(mut self, input: crate::model::FtpIntervalUnit) -> Self {
            self.polling_interval_unit = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_polling_interval_unit(
            mut self,
            input: std::option::Option<crate::model::FtpIntervalUnit>,
        ) -> Self {
            self.polling_interval_unit = input;
            self
        }
        /// The timestamp when the last poll occurred
        pub fn last_poll_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.last_poll_at = Some(input);
            self
        }
        /// The timestamp when the last poll occurred
        pub fn set_last_poll_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.last_poll_at = input;
            self
        }
        /// Number of times to retry connecting
        pub fn retries(mut self, input: i32) -> Self {
            self.retries = Some(input);
            self
        }
        /// Number of times to retry connecting
        pub fn set_retries(mut self, input: std::option::Option<i32>) -> Self {
            self.retries = input;
            self
        }
        /// How long (in ms) to wait for the SSH handshake
        pub fn ready_timeout(mut self, input: i32) -> Self {
            self.ready_timeout = Some(input);
            self
        }
        /// How long (in ms) to wait for the SSH handshake
        pub fn set_ready_timeout(mut self, input: std::option::Option<i32>) -> Self {
            self.ready_timeout = input;
            self
        }
        /// The underlying socket timeout in ms. Default: none
        pub fn timeout(mut self, input: i32) -> Self {
            self.timeout = Some(input);
            self
        }
        /// The underlying socket timeout in ms. Default: none
        pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
            self.timeout = input;
            self
        }
        /// Explicit overrides for the default transport layer algorithms used for the connection
        pub fn algorithms(mut self, input: crate::model::RemoteFtpAlgorithms) -> Self {
            self.algorithms = Some(input);
            self
        }
        /// Explicit overrides for the default transport layer algorithms used for the connection
        pub fn set_algorithms(
            mut self,
            input: std::option::Option<crate::model::RemoteFtpAlgorithms>,
        ) -> Self {
            self.algorithms = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn password(mut self, input: impl Into<std::string::String>) -> Self {
            self.password = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_password(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.password = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn private_key(mut self, input: impl Into<std::string::String>) -> Self {
            self.private_key = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_private_key(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.private_key = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn passphrase(mut self, input: impl Into<std::string::String>) -> Self {
            self.passphrase = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_passphrase(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.passphrase = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateRemoteFtpConnectionInput`](crate::input::CreateRemoteFtpConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateRemoteFtpConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateRemoteFtpConnectionInput {
                name: self.name,
                inbound_subdirectory: self.inbound_subdirectory,
                outbound_subdirectory: self.outbound_subdirectory,
                root_directory: self.root_directory,
                host: self.host,
                username: self.username,
                port: self.port,
                delete_after_retrieval: self.delete_after_retrieval,
                ignore_file_timestamps: self.ignore_file_timestamps,
                enable_polling: self.enable_polling,
                polling_interval: self.polling_interval,
                polling_interval_unit: self.polling_interval_unit,
                last_poll_at: self.last_poll_at,
                retries: self.retries,
                ready_timeout: self.ready_timeout,
                timeout: self.timeout,
                algorithms: self.algorithms,
                password: self.password,
                private_key: self.private_key,
                passphrase: self.passphrase,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl CreateRemoteFtpConnectionInput {
    /// Consumes the builder and constructs an Operation<[`CreateRemoteFtpConnection`](crate::operation::CreateRemoteFtpConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateRemoteFtpConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateRemoteFtpConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_5 = &_input.partnership_id;
                let input_5 = input_5.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_5,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/remote-ftp",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateRemoteFtpConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_remote_ftp_connection(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateRemoteFtpConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateRemoteFtpConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateRemoteFtpConnectionInput`](crate::input::CreateRemoteFtpConnectionInput).
    pub fn builder() -> crate::input::create_remote_ftp_connection_input::Builder {
        crate::input::create_remote_ftp_connection_input::Builder::default()
    }
}

/// See [`CreateStediFtpConnectionInput`](crate::input::CreateStediFtpConnectionInput).
pub mod create_stedi_ftp_connection_input {

    /// A builder for [`CreateStediFtpConnectionInput`](crate::input::CreateStediFtpConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) inbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) outbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) delete_inbound_files_on_receipt: std::option::Option<bool>,
        pub(crate) username: std::option::Option<std::string::String>,
        pub(crate) bucket_name: std::option::Option<std::string::String>,
        pub(crate) home_directory: std::option::Option<std::string::String>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The name of the connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.inbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.outbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn delete_inbound_files_on_receipt(mut self, input: bool) -> Self {
            self.delete_inbound_files_on_receipt = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_delete_inbound_files_on_receipt(
            mut self,
            input: std::option::Option<bool>,
        ) -> Self {
            self.delete_inbound_files_on_receipt = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn username(mut self, input: impl Into<std::string::String>) -> Self {
            self.username = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_username(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.username = input;
            self
        }
        /// The stedi SFTP bucket name
        pub fn bucket_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.bucket_name = Some(input.into());
            self
        }
        /// The stedi SFTP bucket name
        pub fn set_bucket_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.bucket_name = input;
            self
        }
        /// The home directory for this SFTP connection
        pub fn home_directory(mut self, input: impl Into<std::string::String>) -> Self {
            self.home_directory = Some(input.into());
            self
        }
        /// The home directory for this SFTP connection
        pub fn set_home_directory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.home_directory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateStediFtpConnectionInput`](crate::input::CreateStediFtpConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateStediFtpConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateStediFtpConnectionInput {
                name: self.name,
                inbound_subdirectory: self.inbound_subdirectory,
                outbound_subdirectory: self.outbound_subdirectory,
                delete_inbound_files_on_receipt: self.delete_inbound_files_on_receipt,
                username: self.username,
                bucket_name: self.bucket_name,
                home_directory: self.home_directory,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl CreateStediFtpConnectionInput {
    /// Consumes the builder and constructs an Operation<[`CreateStediFtpConnection`](crate::operation::CreateStediFtpConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateStediFtpConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateStediFtpConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_6 = &_input.partnership_id;
                let input_6 = input_6.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_6,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/stedi-ftp",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateStediFtpConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_stedi_ftp_connection(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateStediFtpConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateStediFtpConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateStediFtpConnectionInput`](crate::input::CreateStediFtpConnectionInput).
    pub fn builder() -> crate::input::create_stedi_ftp_connection_input::Builder {
        crate::input::create_stedi_ftp_connection_input::Builder::default()
    }
}

/// See [`CreateX12PartnershipInput`](crate::input::CreateX12PartnershipInput).
pub mod create_x12_partnership_input {

    /// A builder for [`CreateX12PartnershipInput`](crate::input::CreateX12PartnershipInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) local_profile_id: std::option::Option<std::string::String>,
        pub(crate) partner_profile_id: std::option::Option<std::string::String>,
        pub(crate) interchange_usage_indicator:
            std::option::Option<crate::model::X12UsageIndicator>,
        pub(crate) timezone: std::option::Option<crate::model::Timezone>,
        pub(crate) time_format: std::option::Option<crate::model::X12TimeFormat>,
        pub(crate) ack_configuration:
            std::option::Option<crate::model::X12PartnershipAckConfiguration>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_profile_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.local_profile_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_profile_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.local_profile_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_profile_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partner_profile_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_profile_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partner_profile_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn interchange_usage_indicator(
            mut self,
            input: crate::model::X12UsageIndicator,
        ) -> Self {
            self.interchange_usage_indicator = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_interchange_usage_indicator(
            mut self,
            input: std::option::Option<crate::model::X12UsageIndicator>,
        ) -> Self {
            self.interchange_usage_indicator = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn timezone(mut self, input: crate::model::Timezone) -> Self {
            self.timezone = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_timezone(mut self, input: std::option::Option<crate::model::Timezone>) -> Self {
            self.timezone = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn time_format(mut self, input: crate::model::X12TimeFormat) -> Self {
            self.time_format = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_time_format(
            mut self,
            input: std::option::Option<crate::model::X12TimeFormat>,
        ) -> Self {
            self.time_format = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn ack_configuration(
            mut self,
            input: crate::model::X12PartnershipAckConfiguration,
        ) -> Self {
            self.ack_configuration = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_ack_configuration(
            mut self,
            input: std::option::Option<crate::model::X12PartnershipAckConfiguration>,
        ) -> Self {
            self.ack_configuration = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateX12PartnershipInput`](crate::input::CreateX12PartnershipInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateX12PartnershipInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateX12PartnershipInput {
                partnership_id: self.partnership_id,
                local_profile_id: self.local_profile_id,
                partner_profile_id: self.partner_profile_id,
                interchange_usage_indicator: self.interchange_usage_indicator,
                timezone: self.timezone,
                time_format: self.time_format,
                ack_configuration: self.ack_configuration,
            })
        }
    }
}
impl CreateX12PartnershipInput {
    /// Consumes the builder and constructs an Operation<[`CreateX12Partnership`](crate::operation::CreateX12Partnership)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateX12Partnership,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateX12PartnershipInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/x12/partnerships").expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateX12PartnershipInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_x12_partnership(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateX12Partnership::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateX12Partnership",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateX12PartnershipInput`](crate::input::CreateX12PartnershipInput).
    pub fn builder() -> crate::input::create_x12_partnership_input::Builder {
        crate::input::create_x12_partnership_input::Builder::default()
    }
}

/// See [`CreateX12ProfileInput`](crate::input::CreateX12ProfileInput).
pub mod create_x12_profile_input {

    /// A builder for [`CreateX12ProfileInput`](crate::input::CreateX12ProfileInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) interchange_qualifier:
            std::option::Option<crate::model::X12InterchangeQualifier>,
        pub(crate) interchange_id: std::option::Option<std::string::String>,
        pub(crate) profile_id: std::option::Option<std::string::String>,
        pub(crate) profile_type: std::option::Option<crate::model::ProfileType>,
        pub(crate) application_identifiers:
            std::option::Option<std::vec::Vec<crate::model::X12ApplicationId>>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn interchange_qualifier(
            mut self,
            input: crate::model::X12InterchangeQualifier,
        ) -> Self {
            self.interchange_qualifier = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_interchange_qualifier(
            mut self,
            input: std::option::Option<crate::model::X12InterchangeQualifier>,
        ) -> Self {
            self.interchange_qualifier = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn interchange_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.interchange_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_interchange_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.interchange_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn profile_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.profile_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_profile_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.profile_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn profile_type(mut self, input: crate::model::ProfileType) -> Self {
            self.profile_type = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_profile_type(
            mut self,
            input: std::option::Option<crate::model::ProfileType>,
        ) -> Self {
            self.profile_type = input;
            self
        }
        /// Appends an item to `application_identifiers`.
        ///
        /// To override the contents of this collection use [`set_application_identifiers`](Self::set_application_identifiers).
        ///
        /// Store the application ids provided by your partner, with the ability to select one as the default. These values can be used to configure the GS-02, GS-03 of the outbound transaction settings.
        pub fn application_identifiers(mut self, input: crate::model::X12ApplicationId) -> Self {
            let mut v = self.application_identifiers.unwrap_or_default();
            v.push(input);
            self.application_identifiers = Some(v);
            self
        }
        /// Store the application ids provided by your partner, with the ability to select one as the default. These values can be used to configure the GS-02, GS-03 of the outbound transaction settings.
        pub fn set_application_identifiers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::X12ApplicationId>>,
        ) -> Self {
            self.application_identifiers = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateX12ProfileInput`](crate::input::CreateX12ProfileInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::CreateX12ProfileInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::CreateX12ProfileInput {
                interchange_qualifier: self.interchange_qualifier,
                interchange_id: self.interchange_id,
                profile_id: self.profile_id,
                profile_type: self.profile_type,
                application_identifiers: self.application_identifiers,
            })
        }
    }
}
impl CreateX12ProfileInput {
    /// Consumes the builder and constructs an Operation<[`CreateX12Profile`](crate::operation::CreateX12Profile)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::CreateX12Profile,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::CreateX12ProfileInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/x12/profiles").expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::CreateX12ProfileInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_create_x12_profile(&self)?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::CreateX12Profile::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "CreateX12Profile",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`CreateX12ProfileInput`](crate::input::CreateX12ProfileInput).
    pub fn builder() -> crate::input::create_x12_profile_input::Builder {
        crate::input::create_x12_profile_input::Builder::default()
    }
}

/// See [`DeleteAs2BasicAuthInput`](crate::input::DeleteAs2BasicAuthInput).
pub mod delete_as2_basic_auth_input {

    /// A builder for [`DeleteAs2BasicAuthInput`](crate::input::DeleteAs2BasicAuthInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteAs2BasicAuthInput`](crate::input::DeleteAs2BasicAuthInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteAs2BasicAuthInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteAs2BasicAuthInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl DeleteAs2BasicAuthInput {
    /// Consumes the builder and constructs an Operation<[`DeleteAs2BasicAuth`](crate::operation::DeleteAs2BasicAuth)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteAs2BasicAuth,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteAs2BasicAuthInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_7 = &_input.partnership_id;
                let input_7 = input_7.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_7,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_8 = &_input.connection_id;
                let input_8 = input_8.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_8,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/as2/{connectionId}/basic-auth",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteAs2BasicAuthInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteAs2BasicAuth::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteAs2BasicAuth",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteAs2BasicAuthInput`](crate::input::DeleteAs2BasicAuthInput).
    pub fn builder() -> crate::input::delete_as2_basic_auth_input::Builder {
        crate::input::delete_as2_basic_auth_input::Builder::default()
    }
}

/// See [`DeleteAs2ConnectionInput`](crate::input::DeleteAs2ConnectionInput).
pub mod delete_as2_connection_input {

    /// A builder for [`DeleteAs2ConnectionInput`](crate::input::DeleteAs2ConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteAs2ConnectionInput`](crate::input::DeleteAs2ConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteAs2ConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteAs2ConnectionInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl DeleteAs2ConnectionInput {
    /// Consumes the builder and constructs an Operation<[`DeleteAs2Connection`](crate::operation::DeleteAs2Connection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteAs2Connection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteAs2ConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_9 = &_input.partnership_id;
                let input_9 = input_9.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_9,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_10 = &_input.connection_id;
                let input_10 = input_10.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_10,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/as2/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteAs2ConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteAs2Connection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteAs2Connection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteAs2ConnectionInput`](crate::input::DeleteAs2ConnectionInput).
    pub fn builder() -> crate::input::delete_as2_connection_input::Builder {
        crate::input::delete_as2_connection_input::Builder::default()
    }
}

/// See [`DeleteBucketConnectionInput`](crate::input::DeleteBucketConnectionInput).
pub mod delete_bucket_connection_input {

    /// A builder for [`DeleteBucketConnectionInput`](crate::input::DeleteBucketConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteBucketConnectionInput`](crate::input::DeleteBucketConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteBucketConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteBucketConnectionInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl DeleteBucketConnectionInput {
    /// Consumes the builder and constructs an Operation<[`DeleteBucketConnection`](crate::operation::DeleteBucketConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteBucketConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteBucketConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_11 = &_input.partnership_id;
                let input_11 = input_11.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_11,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_12 = &_input.connection_id;
                let input_12 = input_12.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_12,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/buckets/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteBucketConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteBucketConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteBucketConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteBucketConnectionInput`](crate::input::DeleteBucketConnectionInput).
    pub fn builder() -> crate::input::delete_bucket_connection_input::Builder {
        crate::input::delete_bucket_connection_input::Builder::default()
    }
}

/// See [`DeleteGlobalConnectionInput`](crate::input::DeleteGlobalConnectionInput).
pub mod delete_global_connection_input {

    /// A builder for [`DeleteGlobalConnectionInput`](crate::input::DeleteGlobalConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteGlobalConnectionInput`](crate::input::DeleteGlobalConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteGlobalConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteGlobalConnectionInput {
                connection_id: self.connection_id,
            })
        }
    }
}
impl DeleteGlobalConnectionInput {
    /// Consumes the builder and constructs an Operation<[`DeleteGlobalConnection`](crate::operation::DeleteGlobalConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteGlobalConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteGlobalConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_13 = &_input.connection_id;
                let input_13 = input_13.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_13,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/global-connections/{connectionId}",
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteGlobalConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteGlobalConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteGlobalConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteGlobalConnectionInput`](crate::input::DeleteGlobalConnectionInput).
    pub fn builder() -> crate::input::delete_global_connection_input::Builder {
        crate::input::delete_global_connection_input::Builder::default()
    }
}

/// See [`DeleteInboundX12TransactionSettingsInput`](crate::input::DeleteInboundX12TransactionSettingsInput).
pub mod delete_inbound_x12_transaction_settings_input {

    /// A builder for [`DeleteInboundX12TransactionSettingsInput`](crate::input::DeleteInboundX12TransactionSettingsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) inbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_x12_transaction_settings_id(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inbound_x12_transaction_settings_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_x12_transaction_settings_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_x12_transaction_settings_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteInboundX12TransactionSettingsInput`](crate::input::DeleteInboundX12TransactionSettingsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteInboundX12TransactionSettingsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteInboundX12TransactionSettingsInput {
                partnership_id: self.partnership_id,
                inbound_x12_transaction_settings_id: self.inbound_x12_transaction_settings_id,
            })
        }
    }
}
impl DeleteInboundX12TransactionSettingsInput {
    /// Consumes the builder and constructs an Operation<[`DeleteInboundX12TransactionSettings`](crate::operation::DeleteInboundX12TransactionSettings)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteInboundX12TransactionSettings,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteInboundX12TransactionSettingsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_14 = &_input.partnership_id;
                let input_14 = input_14.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_14,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_15 = &_input.inbound_x12_transaction_settings_id;
                let input_15 = input_15.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "inbound_x12_transaction_settings_id",
                        "cannot be empty or unset",
                    )
                })?;
                let inbound_x12_transaction_settings_id = aws_smithy_http::label::fmt_string(
                    input_15,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if inbound_x12_transaction_settings_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "inbound_x12_transaction_settings_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/partnerships/{partnershipId}/inbound-transactions/{inboundX12TransactionSettingsId}", partnershipId = partnership_id, inboundX12TransactionSettingsId = inbound_x12_transaction_settings_id).expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteInboundX12TransactionSettingsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteInboundX12TransactionSettings::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteInboundX12TransactionSettings",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteInboundX12TransactionSettingsInput`](crate::input::DeleteInboundX12TransactionSettingsInput).
    pub fn builder() -> crate::input::delete_inbound_x12_transaction_settings_input::Builder {
        crate::input::delete_inbound_x12_transaction_settings_input::Builder::default()
    }
}

/// See [`DeleteOutboundX12TransactionSettingsInput`](crate::input::DeleteOutboundX12TransactionSettingsInput).
pub mod delete_outbound_x12_transaction_settings_input {

    /// A builder for [`DeleteOutboundX12TransactionSettingsInput`](crate::input::DeleteOutboundX12TransactionSettingsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) outbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_x12_transaction_settings_id(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.outbound_x12_transaction_settings_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_x12_transaction_settings_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_x12_transaction_settings_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteOutboundX12TransactionSettingsInput`](crate::input::DeleteOutboundX12TransactionSettingsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteOutboundX12TransactionSettingsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteOutboundX12TransactionSettingsInput {
                partnership_id: self.partnership_id,
                outbound_x12_transaction_settings_id: self.outbound_x12_transaction_settings_id,
            })
        }
    }
}
impl DeleteOutboundX12TransactionSettingsInput {
    /// Consumes the builder and constructs an Operation<[`DeleteOutboundX12TransactionSettings`](crate::operation::DeleteOutboundX12TransactionSettings)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteOutboundX12TransactionSettings,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteOutboundX12TransactionSettingsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_16 = &_input.partnership_id;
                let input_16 = input_16.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_16,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_17 = &_input.outbound_x12_transaction_settings_id;
                let input_17 = input_17.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "outbound_x12_transaction_settings_id",
                        "cannot be empty or unset",
                    )
                })?;
                let outbound_x12_transaction_settings_id = aws_smithy_http::label::fmt_string(
                    input_17,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if outbound_x12_transaction_settings_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "outbound_x12_transaction_settings_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/partnerships/{partnershipId}/outbound-transactions/{outboundX12TransactionSettingsId}", partnershipId = partnership_id, outboundX12TransactionSettingsId = outbound_x12_transaction_settings_id).expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteOutboundX12TransactionSettingsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteOutboundX12TransactionSettings::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteOutboundX12TransactionSettings",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteOutboundX12TransactionSettingsInput`](crate::input::DeleteOutboundX12TransactionSettingsInput).
    pub fn builder() -> crate::input::delete_outbound_x12_transaction_settings_input::Builder {
        crate::input::delete_outbound_x12_transaction_settings_input::Builder::default()
    }
}

/// See [`DeleteRemoteFtpConnectionInput`](crate::input::DeleteRemoteFtpConnectionInput).
pub mod delete_remote_ftp_connection_input {

    /// A builder for [`DeleteRemoteFtpConnectionInput`](crate::input::DeleteRemoteFtpConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteRemoteFtpConnectionInput`](crate::input::DeleteRemoteFtpConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteRemoteFtpConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteRemoteFtpConnectionInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl DeleteRemoteFtpConnectionInput {
    /// Consumes the builder and constructs an Operation<[`DeleteRemoteFtpConnection`](crate::operation::DeleteRemoteFtpConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteRemoteFtpConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteRemoteFtpConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_18 = &_input.partnership_id;
                let input_18 = input_18.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_18,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_19 = &_input.connection_id;
                let input_19 = input_19.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_19,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/remote-ftp/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteRemoteFtpConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteRemoteFtpConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteRemoteFtpConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteRemoteFtpConnectionInput`](crate::input::DeleteRemoteFtpConnectionInput).
    pub fn builder() -> crate::input::delete_remote_ftp_connection_input::Builder {
        crate::input::delete_remote_ftp_connection_input::Builder::default()
    }
}

/// See [`DeleteStediFtpConnectionInput`](crate::input::DeleteStediFtpConnectionInput).
pub mod delete_stedi_ftp_connection_input {

    /// A builder for [`DeleteStediFtpConnectionInput`](crate::input::DeleteStediFtpConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteStediFtpConnectionInput`](crate::input::DeleteStediFtpConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteStediFtpConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteStediFtpConnectionInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl DeleteStediFtpConnectionInput {
    /// Consumes the builder and constructs an Operation<[`DeleteStediFtpConnection`](crate::operation::DeleteStediFtpConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteStediFtpConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteStediFtpConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_20 = &_input.partnership_id;
                let input_20 = input_20.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_20,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_21 = &_input.connection_id;
                let input_21 = input_21.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_21,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/stedi-ftp/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteStediFtpConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteStediFtpConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteStediFtpConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteStediFtpConnectionInput`](crate::input::DeleteStediFtpConnectionInput).
    pub fn builder() -> crate::input::delete_stedi_ftp_connection_input::Builder {
        crate::input::delete_stedi_ftp_connection_input::Builder::default()
    }
}

/// See [`DeleteX12PartnershipInput`](crate::input::DeleteX12PartnershipInput).
pub mod delete_x12_partnership_input {

    /// A builder for [`DeleteX12PartnershipInput`](crate::input::DeleteX12PartnershipInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteX12PartnershipInput`](crate::input::DeleteX12PartnershipInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteX12PartnershipInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteX12PartnershipInput {
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl DeleteX12PartnershipInput {
    /// Consumes the builder and constructs an Operation<[`DeleteX12Partnership`](crate::operation::DeleteX12Partnership)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteX12Partnership,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteX12PartnershipInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_22 = &_input.partnership_id;
                let input_22 = input_22.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_22,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteX12PartnershipInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteX12Partnership::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteX12Partnership",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteX12PartnershipInput`](crate::input::DeleteX12PartnershipInput).
    pub fn builder() -> crate::input::delete_x12_partnership_input::Builder {
        crate::input::delete_x12_partnership_input::Builder::default()
    }
}

/// See [`DeleteX12ProfileInput`](crate::input::DeleteX12ProfileInput).
pub mod delete_x12_profile_input {

    /// A builder for [`DeleteX12ProfileInput`](crate::input::DeleteX12ProfileInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) profile_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn profile_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.profile_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_profile_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.profile_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteX12ProfileInput`](crate::input::DeleteX12ProfileInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::DeleteX12ProfileInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::DeleteX12ProfileInput {
                profile_id: self.profile_id,
            })
        }
    }
}
impl DeleteX12ProfileInput {
    /// Consumes the builder and constructs an Operation<[`DeleteX12Profile`](crate::operation::DeleteX12Profile)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::DeleteX12Profile,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::DeleteX12ProfileInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_23 = &_input.profile_id;
                let input_23 = input_23.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "profile_id",
                        "cannot be empty or unset",
                    )
                })?;
                let profile_id = aws_smithy_http::label::fmt_string(
                    input_23,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if profile_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "profile_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/profiles/{profileId}", profileId = profile_id)
                    .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::DeleteX12ProfileInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("DELETE").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::DeleteX12Profile::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "DeleteX12Profile",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`DeleteX12ProfileInput`](crate::input::DeleteX12ProfileInput).
    pub fn builder() -> crate::input::delete_x12_profile_input::Builder {
        crate::input::delete_x12_profile_input::Builder::default()
    }
}

/// See [`GenerateEdiInput`](crate::input::GenerateEdiInput).
pub mod generate_edi_input {

    /// A builder for [`GenerateEdiInput`](crate::input::GenerateEdiInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) transaction_groups:
            std::option::Option<std::vec::Vec<crate::model::TransactionGroup>>,
        pub(crate) interchange_usage_indicator_override:
            std::option::Option<crate::model::X12UsageIndicator>,
        pub(crate) filename: std::option::Option<std::string::String>,
        pub(crate) interchange_authorization:
            std::option::Option<crate::model::X12InterchangeAuthorization>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `transaction_groups`.
        ///
        /// To override the contents of this collection use [`set_transaction_groups`](Self::set_transaction_groups).
        ///
        pub fn transaction_groups(mut self, input: crate::model::TransactionGroup) -> Self {
            let mut v = self.transaction_groups.unwrap_or_default();
            v.push(input);
            self.transaction_groups = Some(v);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_transaction_groups(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::TransactionGroup>>,
        ) -> Self {
            self.transaction_groups = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn interchange_usage_indicator_override(
            mut self,
            input: crate::model::X12UsageIndicator,
        ) -> Self {
            self.interchange_usage_indicator_override = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_interchange_usage_indicator_override(
            mut self,
            input: std::option::Option<crate::model::X12UsageIndicator>,
        ) -> Self {
            self.interchange_usage_indicator_override = input;
            self
        }
        /// Filename used to save the generated artifact
        pub fn filename(mut self, input: impl Into<std::string::String>) -> Self {
            self.filename = Some(input.into());
            self
        }
        /// Filename used to save the generated artifact
        pub fn set_filename(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.filename = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn interchange_authorization(
            mut self,
            input: crate::model::X12InterchangeAuthorization,
        ) -> Self {
            self.interchange_authorization = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_interchange_authorization(
            mut self,
            input: std::option::Option<crate::model::X12InterchangeAuthorization>,
        ) -> Self {
            self.interchange_authorization = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GenerateEdiInput`](crate::input::GenerateEdiInput).
        pub fn build(
            self,
        ) -> Result<crate::input::GenerateEdiInput, aws_smithy_http::operation::error::BuildError>
        {
            Ok(crate::input::GenerateEdiInput {
                transaction_groups: self.transaction_groups,
                interchange_usage_indicator_override: self.interchange_usage_indicator_override,
                filename: self.filename,
                interchange_authorization: self.interchange_authorization,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl GenerateEdiInput {
    /// Consumes the builder and constructs an Operation<[`GenerateEdi`](crate::operation::GenerateEdi)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GenerateEdi,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GenerateEdiInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_24 = &_input.partnership_id;
                let input_24 = input_24.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_24,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/generate-edi",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GenerateEdiInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_generate_edi(&self)?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GenerateEdi::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GenerateEdi",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GenerateEdiInput`](crate::input::GenerateEdiInput).
    pub fn builder() -> crate::input::generate_edi_input::Builder {
        crate::input::generate_edi_input::Builder::default()
    }
}

/// See [`GetAs2ConnectionInput`](crate::input::GetAs2ConnectionInput).
pub mod get_as2_connection_input {

    /// A builder for [`GetAs2ConnectionInput`](crate::input::GetAs2ConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAs2ConnectionInput`](crate::input::GetAs2ConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetAs2ConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetAs2ConnectionInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl GetAs2ConnectionInput {
    /// Consumes the builder and constructs an Operation<[`GetAs2Connection`](crate::operation::GetAs2Connection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetAs2Connection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetAs2ConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_25 = &_input.partnership_id;
                let input_25 = input_25.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_25,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_26 = &_input.connection_id;
                let input_26 = input_26.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_26,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/as2/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetAs2ConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetAs2Connection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetAs2Connection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetAs2ConnectionInput`](crate::input::GetAs2ConnectionInput).
    pub fn builder() -> crate::input::get_as2_connection_input::Builder {
        crate::input::get_as2_connection_input::Builder::default()
    }
}

/// See [`GetBucketConnectionInput`](crate::input::GetBucketConnectionInput).
pub mod get_bucket_connection_input {

    /// A builder for [`GetBucketConnectionInput`](crate::input::GetBucketConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetBucketConnectionInput`](crate::input::GetBucketConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetBucketConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetBucketConnectionInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl GetBucketConnectionInput {
    /// Consumes the builder and constructs an Operation<[`GetBucketConnection`](crate::operation::GetBucketConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetBucketConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetBucketConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_27 = &_input.partnership_id;
                let input_27 = input_27.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_27,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_28 = &_input.connection_id;
                let input_28 = input_28.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_28,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/buckets/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetBucketConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetBucketConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetBucketConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetBucketConnectionInput`](crate::input::GetBucketConnectionInput).
    pub fn builder() -> crate::input::get_bucket_connection_input::Builder {
        crate::input::get_bucket_connection_input::Builder::default()
    }
}

/// See [`GetConnectionsInput`](crate::input::GetConnectionsInput).
pub mod get_connections_input {

    /// A builder for [`GetConnectionsInput`](crate::input::GetConnectionsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetConnectionsInput`](crate::input::GetConnectionsInput).
        pub fn build(
            self,
        ) -> Result<crate::input::GetConnectionsInput, aws_smithy_http::operation::error::BuildError>
        {
            Ok(crate::input::GetConnectionsInput {
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl GetConnectionsInput {
    /// Consumes the builder and constructs an Operation<[`GetConnections`](crate::operation::GetConnections)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetConnections,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetConnectionsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_29 = &_input.partnership_id;
                let input_29 = input_29.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_29,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetConnectionsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetConnections::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetConnections",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetConnectionsInput`](crate::input::GetConnectionsInput).
    pub fn builder() -> crate::input::get_connections_input::Builder {
        crate::input::get_connections_input::Builder::default()
    }
}

/// See [`GetGlobalConnectionInput`](crate::input::GetGlobalConnectionInput).
pub mod get_global_connection_input {

    /// A builder for [`GetGlobalConnectionInput`](crate::input::GetGlobalConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetGlobalConnectionInput`](crate::input::GetGlobalConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetGlobalConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetGlobalConnectionInput {
                connection_id: self.connection_id,
            })
        }
    }
}
impl GetGlobalConnectionInput {
    /// Consumes the builder and constructs an Operation<[`GetGlobalConnection`](crate::operation::GetGlobalConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetGlobalConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetGlobalConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_30 = &_input.connection_id;
                let input_30 = input_30.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_30,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/global-connections/{connectionId}",
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetGlobalConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetGlobalConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetGlobalConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetGlobalConnectionInput`](crate::input::GetGlobalConnectionInput).
    pub fn builder() -> crate::input::get_global_connection_input::Builder {
        crate::input::get_global_connection_input::Builder::default()
    }
}

/// See [`GetInboundX12TransactionSettingsInput`](crate::input::GetInboundX12TransactionSettingsInput).
pub mod get_inbound_x12_transaction_settings_input {

    /// A builder for [`GetInboundX12TransactionSettingsInput`](crate::input::GetInboundX12TransactionSettingsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) inbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_x12_transaction_settings_id(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inbound_x12_transaction_settings_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_x12_transaction_settings_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_x12_transaction_settings_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetInboundX12TransactionSettingsInput`](crate::input::GetInboundX12TransactionSettingsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetInboundX12TransactionSettingsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetInboundX12TransactionSettingsInput {
                partnership_id: self.partnership_id,
                inbound_x12_transaction_settings_id: self.inbound_x12_transaction_settings_id,
            })
        }
    }
}
impl GetInboundX12TransactionSettingsInput {
    /// Consumes the builder and constructs an Operation<[`GetInboundX12TransactionSettings`](crate::operation::GetInboundX12TransactionSettings)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetInboundX12TransactionSettings,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetInboundX12TransactionSettingsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_31 = &_input.partnership_id;
                let input_31 = input_31.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_31,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_32 = &_input.inbound_x12_transaction_settings_id;
                let input_32 = input_32.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "inbound_x12_transaction_settings_id",
                        "cannot be empty or unset",
                    )
                })?;
                let inbound_x12_transaction_settings_id = aws_smithy_http::label::fmt_string(
                    input_32,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if inbound_x12_transaction_settings_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "inbound_x12_transaction_settings_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/partnerships/{partnershipId}/inbound-transactions/{inboundX12TransactionSettingsId}", partnershipId = partnership_id, inboundX12TransactionSettingsId = inbound_x12_transaction_settings_id).expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetInboundX12TransactionSettingsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetInboundX12TransactionSettings::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetInboundX12TransactionSettings",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetInboundX12TransactionSettingsInput`](crate::input::GetInboundX12TransactionSettingsInput).
    pub fn builder() -> crate::input::get_inbound_x12_transaction_settings_input::Builder {
        crate::input::get_inbound_x12_transaction_settings_input::Builder::default()
    }
}

/// See [`GetOutboundX12ControlNumbersInput`](crate::input::GetOutboundX12ControlNumbersInput).
pub mod get_outbound_x12_control_numbers_input {

    /// A builder for [`GetOutboundX12ControlNumbersInput`](crate::input::GetOutboundX12ControlNumbersInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetOutboundX12ControlNumbersInput`](crate::input::GetOutboundX12ControlNumbersInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetOutboundX12ControlNumbersInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetOutboundX12ControlNumbersInput {
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl GetOutboundX12ControlNumbersInput {
    /// Consumes the builder and constructs an Operation<[`GetOutboundX12ControlNumbers`](crate::operation::GetOutboundX12ControlNumbers)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetOutboundX12ControlNumbers,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetOutboundX12ControlNumbersInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_33 = &_input.partnership_id;
                let input_33 = input_33.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_33,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/outbound-control-numbers",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetOutboundX12ControlNumbersInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetOutboundX12ControlNumbers::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetOutboundX12ControlNumbers",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetOutboundX12ControlNumbersInput`](crate::input::GetOutboundX12ControlNumbersInput).
    pub fn builder() -> crate::input::get_outbound_x12_control_numbers_input::Builder {
        crate::input::get_outbound_x12_control_numbers_input::Builder::default()
    }
}

/// See [`GetOutboundX12TransactionSettingsInput`](crate::input::GetOutboundX12TransactionSettingsInput).
pub mod get_outbound_x12_transaction_settings_input {

    /// A builder for [`GetOutboundX12TransactionSettingsInput`](crate::input::GetOutboundX12TransactionSettingsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) outbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_x12_transaction_settings_id(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.outbound_x12_transaction_settings_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_x12_transaction_settings_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_x12_transaction_settings_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetOutboundX12TransactionSettingsInput`](crate::input::GetOutboundX12TransactionSettingsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetOutboundX12TransactionSettingsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetOutboundX12TransactionSettingsInput {
                partnership_id: self.partnership_id,
                outbound_x12_transaction_settings_id: self.outbound_x12_transaction_settings_id,
            })
        }
    }
}
impl GetOutboundX12TransactionSettingsInput {
    /// Consumes the builder and constructs an Operation<[`GetOutboundX12TransactionSettings`](crate::operation::GetOutboundX12TransactionSettings)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetOutboundX12TransactionSettings,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetOutboundX12TransactionSettingsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_34 = &_input.partnership_id;
                let input_34 = input_34.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_34,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_35 = &_input.outbound_x12_transaction_settings_id;
                let input_35 = input_35.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "outbound_x12_transaction_settings_id",
                        "cannot be empty or unset",
                    )
                })?;
                let outbound_x12_transaction_settings_id = aws_smithy_http::label::fmt_string(
                    input_35,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if outbound_x12_transaction_settings_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "outbound_x12_transaction_settings_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/partnerships/{partnershipId}/outbound-transactions/{outboundX12TransactionSettingsId}", partnershipId = partnership_id, outboundX12TransactionSettingsId = outbound_x12_transaction_settings_id).expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetOutboundX12TransactionSettingsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetOutboundX12TransactionSettings::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetOutboundX12TransactionSettings",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetOutboundX12TransactionSettingsInput`](crate::input::GetOutboundX12TransactionSettingsInput).
    pub fn builder() -> crate::input::get_outbound_x12_transaction_settings_input::Builder {
        crate::input::get_outbound_x12_transaction_settings_input::Builder::default()
    }
}

/// See [`GetRemoteFtpConnectionInput`](crate::input::GetRemoteFtpConnectionInput).
pub mod get_remote_ftp_connection_input {

    /// A builder for [`GetRemoteFtpConnectionInput`](crate::input::GetRemoteFtpConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetRemoteFtpConnectionInput`](crate::input::GetRemoteFtpConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetRemoteFtpConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetRemoteFtpConnectionInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl GetRemoteFtpConnectionInput {
    /// Consumes the builder and constructs an Operation<[`GetRemoteFtpConnection`](crate::operation::GetRemoteFtpConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetRemoteFtpConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetRemoteFtpConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_36 = &_input.partnership_id;
                let input_36 = input_36.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_36,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_37 = &_input.connection_id;
                let input_37 = input_37.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_37,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/remote-ftp/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetRemoteFtpConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetRemoteFtpConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetRemoteFtpConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetRemoteFtpConnectionInput`](crate::input::GetRemoteFtpConnectionInput).
    pub fn builder() -> crate::input::get_remote_ftp_connection_input::Builder {
        crate::input::get_remote_ftp_connection_input::Builder::default()
    }
}

/// See [`GetStediFtpConnectionInput`](crate::input::GetStediFtpConnectionInput).
pub mod get_stedi_ftp_connection_input {

    /// A builder for [`GetStediFtpConnectionInput`](crate::input::GetStediFtpConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetStediFtpConnectionInput`](crate::input::GetStediFtpConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetStediFtpConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetStediFtpConnectionInput {
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl GetStediFtpConnectionInput {
    /// Consumes the builder and constructs an Operation<[`GetStediFtpConnection`](crate::operation::GetStediFtpConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetStediFtpConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetStediFtpConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_38 = &_input.partnership_id;
                let input_38 = input_38.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_38,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_39 = &_input.connection_id;
                let input_39 = input_39.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_39,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/stedi-ftp/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetStediFtpConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetStediFtpConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetStediFtpConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetStediFtpConnectionInput`](crate::input::GetStediFtpConnectionInput).
    pub fn builder() -> crate::input::get_stedi_ftp_connection_input::Builder {
        crate::input::get_stedi_ftp_connection_input::Builder::default()
    }
}

/// See [`GetX12PartnershipInput`](crate::input::GetX12PartnershipInput).
pub mod get_x12_partnership_input {

    /// A builder for [`GetX12PartnershipInput`](crate::input::GetX12PartnershipInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetX12PartnershipInput`](crate::input::GetX12PartnershipInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetX12PartnershipInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetX12PartnershipInput {
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl GetX12PartnershipInput {
    /// Consumes the builder and constructs an Operation<[`GetX12Partnership`](crate::operation::GetX12Partnership)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetX12Partnership,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetX12PartnershipInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_40 = &_input.partnership_id;
                let input_40 = input_40.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_40,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetX12PartnershipInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetX12Partnership::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetX12Partnership",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetX12PartnershipInput`](crate::input::GetX12PartnershipInput).
    pub fn builder() -> crate::input::get_x12_partnership_input::Builder {
        crate::input::get_x12_partnership_input::Builder::default()
    }
}

/// See [`GetX12PartnershipByInterchangesInput`](crate::input::GetX12PartnershipByInterchangesInput).
pub mod get_x12_partnership_by_interchanges_input {

    /// A builder for [`GetX12PartnershipByInterchangesInput`](crate::input::GetX12PartnershipByInterchangesInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) local_interchange_identifier:
            std::option::Option<crate::model::X12InterchangeIdentifier>,
        pub(crate) partner_interchange_identifier:
            std::option::Option<crate::model::X12InterchangeIdentifier>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_interchange_identifier(
            mut self,
            input: crate::model::X12InterchangeIdentifier,
        ) -> Self {
            self.local_interchange_identifier = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_interchange_identifier(
            mut self,
            input: std::option::Option<crate::model::X12InterchangeIdentifier>,
        ) -> Self {
            self.local_interchange_identifier = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_interchange_identifier(
            mut self,
            input: crate::model::X12InterchangeIdentifier,
        ) -> Self {
            self.partner_interchange_identifier = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_interchange_identifier(
            mut self,
            input: std::option::Option<crate::model::X12InterchangeIdentifier>,
        ) -> Self {
            self.partner_interchange_identifier = input;
            self
        }
        /// Consumes the builder and constructs a [`GetX12PartnershipByInterchangesInput`](crate::input::GetX12PartnershipByInterchangesInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetX12PartnershipByInterchangesInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetX12PartnershipByInterchangesInput {
                local_interchange_identifier: self.local_interchange_identifier,
                partner_interchange_identifier: self.partner_interchange_identifier,
            })
        }
    }
}
impl GetX12PartnershipByInterchangesInput {
    /// Consumes the builder and constructs an Operation<[`GetX12PartnershipByInterchanges`](crate::operation::GetX12PartnershipByInterchanges)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetX12PartnershipByInterchanges,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetX12PartnershipByInterchangesInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/x12/get-partnership-by-interchanges")
                    .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetX12PartnershipByInterchangesInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_get_x12_partnership_by_interchanges(&self)?
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetX12PartnershipByInterchanges::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetX12PartnershipByInterchanges",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetX12PartnershipByInterchangesInput`](crate::input::GetX12PartnershipByInterchangesInput).
    pub fn builder() -> crate::input::get_x12_partnership_by_interchanges_input::Builder {
        crate::input::get_x12_partnership_by_interchanges_input::Builder::default()
    }
}

/// See [`GetX12ProfileInput`](crate::input::GetX12ProfileInput).
pub mod get_x12_profile_input {

    /// A builder for [`GetX12ProfileInput`](crate::input::GetX12ProfileInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) profile_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn profile_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.profile_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_profile_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.profile_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetX12ProfileInput`](crate::input::GetX12ProfileInput).
        pub fn build(
            self,
        ) -> Result<crate::input::GetX12ProfileInput, aws_smithy_http::operation::error::BuildError>
        {
            Ok(crate::input::GetX12ProfileInput {
                profile_id: self.profile_id,
            })
        }
    }
}
impl GetX12ProfileInput {
    /// Consumes the builder and constructs an Operation<[`GetX12Profile`](crate::operation::GetX12Profile)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetX12Profile,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetX12ProfileInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_41 = &_input.profile_id;
                let input_41 = input_41.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "profile_id",
                        "cannot be empty or unset",
                    )
                })?;
                let profile_id = aws_smithy_http::label::fmt_string(
                    input_41,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if profile_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "profile_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/profiles/{profileId}", profileId = profile_id)
                    .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetX12ProfileInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetX12Profile::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetX12Profile",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetX12ProfileInput`](crate::input::GetX12ProfileInput).
    pub fn builder() -> crate::input::get_x12_profile_input::Builder {
        crate::input::get_x12_profile_input::Builder::default()
    }
}

/// See [`GetX12ProfileByInterchangeInput`](crate::input::GetX12ProfileByInterchangeInput).
pub mod get_x12_profile_by_interchange_input {

    /// A builder for [`GetX12ProfileByInterchangeInput`](crate::input::GetX12ProfileByInterchangeInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) interchange_identifier:
            std::option::Option<crate::model::X12InterchangeIdentifier>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn interchange_identifier(
            mut self,
            input: crate::model::X12InterchangeIdentifier,
        ) -> Self {
            self.interchange_identifier = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_interchange_identifier(
            mut self,
            input: std::option::Option<crate::model::X12InterchangeIdentifier>,
        ) -> Self {
            self.interchange_identifier = input;
            self
        }
        /// Consumes the builder and constructs a [`GetX12ProfileByInterchangeInput`](crate::input::GetX12ProfileByInterchangeInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::GetX12ProfileByInterchangeInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::GetX12ProfileByInterchangeInput {
                interchange_identifier: self.interchange_identifier,
            })
        }
    }
}
impl GetX12ProfileByInterchangeInput {
    /// Consumes the builder and constructs an Operation<[`GetX12ProfileByInterchange`](crate::operation::GetX12ProfileByInterchange)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::GetX12ProfileByInterchange,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::GetX12ProfileByInterchangeInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/x12/get-profile-by-interchange")
                    .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::GetX12ProfileByInterchangeInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_get_x12_profile_by_interchange(&self)?
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::GetX12ProfileByInterchange::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "GetX12ProfileByInterchange",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`GetX12ProfileByInterchangeInput`](crate::input::GetX12ProfileByInterchangeInput).
    pub fn builder() -> crate::input::get_x12_profile_by_interchange_input::Builder {
        crate::input::get_x12_profile_by_interchange_input::Builder::default()
    }
}

/// See [`IncrementX12ControlNumberInput`](crate::input::IncrementX12ControlNumberInput).
pub mod increment_x12_control_number_input {

    /// A builder for [`IncrementX12ControlNumberInput`](crate::input::IncrementX12ControlNumberInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) control_number_type: std::option::Option<crate::model::X12ControlNumberType>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn control_number_type(mut self, input: crate::model::X12ControlNumberType) -> Self {
            self.control_number_type = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_control_number_type(
            mut self,
            input: std::option::Option<crate::model::X12ControlNumberType>,
        ) -> Self {
            self.control_number_type = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`IncrementX12ControlNumberInput`](crate::input::IncrementX12ControlNumberInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::IncrementX12ControlNumberInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::IncrementX12ControlNumberInput {
                control_number_type: self.control_number_type,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl IncrementX12ControlNumberInput {
    /// Consumes the builder and constructs an Operation<[`IncrementX12ControlNumber`](crate::operation::IncrementX12ControlNumber)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::IncrementX12ControlNumber,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::IncrementX12ControlNumberInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/x12/outbound-control-numbers/increment")
                    .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::IncrementX12ControlNumberInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_increment_x12_control_number(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::IncrementX12ControlNumber::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "IncrementX12ControlNumber",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`IncrementX12ControlNumberInput`](crate::input::IncrementX12ControlNumberInput).
    pub fn builder() -> crate::input::increment_x12_control_number_input::Builder {
        crate::input::increment_x12_control_number_input::Builder::default()
    }
}

/// See [`ListGlobalConnectionsInput`](crate::input::ListGlobalConnectionsInput).
pub mod list_global_connections_input {

    /// A builder for [`ListGlobalConnectionsInput`](crate::input::ListGlobalConnectionsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) page_size: std::option::Option<i32>,
        pub(crate) page_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The maximum number of elements to return in a page
        pub fn page_size(mut self, input: i32) -> Self {
            self.page_size = Some(input);
            self
        }
        /// The maximum number of elements to return in a page
        pub fn set_page_size(mut self, input: std::option::Option<i32>) -> Self {
            self.page_size = input;
            self
        }
        /// The token used for pagination
        pub fn page_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.page_token = Some(input.into());
            self
        }
        /// The token used for pagination
        pub fn set_page_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.page_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListGlobalConnectionsInput`](crate::input::ListGlobalConnectionsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::ListGlobalConnectionsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::ListGlobalConnectionsInput {
                page_size: self.page_size,
                page_token: self.page_token,
            })
        }
    }
}
impl ListGlobalConnectionsInput {
    /// Consumes the builder and constructs an Operation<[`ListGlobalConnections`](crate::operation::ListGlobalConnections)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::ListGlobalConnections,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::ListGlobalConnectionsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/global-connections").expect("formatting should succeed");
                Ok(())
            }
            fn uri_query(
                _input: &crate::input::ListGlobalConnectionsInput,
                mut output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let mut query = aws_smithy_http::query::Writer::new(&mut output);
                if let Some(inner_42) = &_input.page_size {
                    if *inner_42 != 0 {
                        query.push_kv(
                            "pageSize",
                            aws_smithy_types::primitive::Encoder::from(*inner_42).encode(),
                        );
                    }
                }
                if let Some(inner_43) = &_input.page_token {
                    {
                        query.push_kv("pageToken", &aws_smithy_http::query::fmt_string(&inner_43));
                    }
                }
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::ListGlobalConnectionsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                uri_query(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::ListGlobalConnections::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "ListGlobalConnections",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`ListGlobalConnectionsInput`](crate::input::ListGlobalConnectionsInput).
    pub fn builder() -> crate::input::list_global_connections_input::Builder {
        crate::input::list_global_connections_input::Builder::default()
    }
}

/// See [`ListX12PartnershipsInput`](crate::input::ListX12PartnershipsInput).
pub mod list_x12_partnerships_input {

    /// A builder for [`ListX12PartnershipsInput`](crate::input::ListX12PartnershipsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) page_size: std::option::Option<i32>,
        pub(crate) page_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The maximum number of elements to return in a page
        pub fn page_size(mut self, input: i32) -> Self {
            self.page_size = Some(input);
            self
        }
        /// The maximum number of elements to return in a page
        pub fn set_page_size(mut self, input: std::option::Option<i32>) -> Self {
            self.page_size = input;
            self
        }
        /// The token used for pagination
        pub fn page_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.page_token = Some(input.into());
            self
        }
        /// The token used for pagination
        pub fn set_page_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.page_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListX12PartnershipsInput`](crate::input::ListX12PartnershipsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::ListX12PartnershipsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::ListX12PartnershipsInput {
                page_size: self.page_size,
                page_token: self.page_token,
            })
        }
    }
}
impl ListX12PartnershipsInput {
    /// Consumes the builder and constructs an Operation<[`ListX12Partnerships`](crate::operation::ListX12Partnerships)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::ListX12Partnerships,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::ListX12PartnershipsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/x12/partnerships").expect("formatting should succeed");
                Ok(())
            }
            fn uri_query(
                _input: &crate::input::ListX12PartnershipsInput,
                mut output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let mut query = aws_smithy_http::query::Writer::new(&mut output);
                if let Some(inner_44) = &_input.page_size {
                    if *inner_44 != 0 {
                        query.push_kv(
                            "pageSize",
                            aws_smithy_types::primitive::Encoder::from(*inner_44).encode(),
                        );
                    }
                }
                if let Some(inner_45) = &_input.page_token {
                    {
                        query.push_kv("pageToken", &aws_smithy_http::query::fmt_string(&inner_45));
                    }
                }
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::ListX12PartnershipsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                uri_query(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::ListX12Partnerships::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "ListX12Partnerships",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`ListX12PartnershipsInput`](crate::input::ListX12PartnershipsInput).
    pub fn builder() -> crate::input::list_x12_partnerships_input::Builder {
        crate::input::list_x12_partnerships_input::Builder::default()
    }
}

/// See [`ListX12ProfilesInput`](crate::input::ListX12ProfilesInput).
pub mod list_x12_profiles_input {

    /// A builder for [`ListX12ProfilesInput`](crate::input::ListX12ProfilesInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) page_size: std::option::Option<i32>,
        pub(crate) page_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The maximum number of elements to return in a page
        pub fn page_size(mut self, input: i32) -> Self {
            self.page_size = Some(input);
            self
        }
        /// The maximum number of elements to return in a page
        pub fn set_page_size(mut self, input: std::option::Option<i32>) -> Self {
            self.page_size = input;
            self
        }
        /// The token used for pagination
        pub fn page_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.page_token = Some(input.into());
            self
        }
        /// The token used for pagination
        pub fn set_page_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.page_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListX12ProfilesInput`](crate::input::ListX12ProfilesInput).
        pub fn build(
            self,
        ) -> Result<crate::input::ListX12ProfilesInput, aws_smithy_http::operation::error::BuildError>
        {
            Ok(crate::input::ListX12ProfilesInput {
                page_size: self.page_size,
                page_token: self.page_token,
            })
        }
    }
}
impl ListX12ProfilesInput {
    /// Consumes the builder and constructs an Operation<[`ListX12Profiles`](crate::operation::ListX12Profiles)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::ListX12Profiles,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::ListX12ProfilesInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                write!(output, "/x12/profiles").expect("formatting should succeed");
                Ok(())
            }
            fn uri_query(
                _input: &crate::input::ListX12ProfilesInput,
                mut output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let mut query = aws_smithy_http::query::Writer::new(&mut output);
                if let Some(inner_46) = &_input.page_size {
                    if *inner_46 != 0 {
                        query.push_kv(
                            "pageSize",
                            aws_smithy_types::primitive::Encoder::from(*inner_46).encode(),
                        );
                    }
                }
                if let Some(inner_47) = &_input.page_token {
                    {
                        query.push_kv("pageToken", &aws_smithy_http::query::fmt_string(&inner_47));
                    }
                }
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::ListX12ProfilesInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                uri_query(input, &mut uri)?;
                Ok(builder.method("GET").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from("");
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::ListX12Profiles::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "ListX12Profiles",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`ListX12ProfilesInput`](crate::input::ListX12ProfilesInput).
    pub fn builder() -> crate::input::list_x12_profiles_input::Builder {
        crate::input::list_x12_profiles_input::Builder::default()
    }
}

/// See [`SetOutboundX12ControlNumberInput`](crate::input::SetOutboundX12ControlNumberInput).
pub mod set_outbound_x12_control_number_input {

    /// A builder for [`SetOutboundX12ControlNumberInput`](crate::input::SetOutboundX12ControlNumberInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) x12_control_number: std::option::Option<i64>,
        pub(crate) control_number_type: std::option::Option<crate::model::X12ControlNumberType>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn x12_control_number(mut self, input: i64) -> Self {
            self.x12_control_number = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_x12_control_number(mut self, input: std::option::Option<i64>) -> Self {
            self.x12_control_number = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn control_number_type(mut self, input: crate::model::X12ControlNumberType) -> Self {
            self.control_number_type = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_control_number_type(
            mut self,
            input: std::option::Option<crate::model::X12ControlNumberType>,
        ) -> Self {
            self.control_number_type = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`SetOutboundX12ControlNumberInput`](crate::input::SetOutboundX12ControlNumberInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::SetOutboundX12ControlNumberInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::SetOutboundX12ControlNumberInput {
                x12_control_number: self.x12_control_number,
                control_number_type: self.control_number_type,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl SetOutboundX12ControlNumberInput {
    /// Consumes the builder and constructs an Operation<[`SetOutboundX12ControlNumber`](crate::operation::SetOutboundX12ControlNumber)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::SetOutboundX12ControlNumber,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::SetOutboundX12ControlNumberInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_48 = &_input.partnership_id;
                let input_48 = input_48.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_48,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/outbound-control-numbers",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::SetOutboundX12ControlNumberInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_set_outbound_x12_control_number(&self)?
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::SetOutboundX12ControlNumber::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "SetOutboundX12ControlNumber",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`SetOutboundX12ControlNumberInput`](crate::input::SetOutboundX12ControlNumberInput).
    pub fn builder() -> crate::input::set_outbound_x12_control_number_input::Builder {
        crate::input::set_outbound_x12_control_number_input::Builder::default()
    }
}

/// See [`UpdateAs2BasicAuthInput`](crate::input::UpdateAs2BasicAuthInput).
pub mod update_as2_basic_auth_input {

    /// A builder for [`UpdateAs2BasicAuthInput`](crate::input::UpdateAs2BasicAuthInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) username: std::option::Option<std::string::String>,
        pub(crate) password: std::option::Option<std::string::String>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn username(mut self, input: impl Into<std::string::String>) -> Self {
            self.username = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_username(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.username = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn password(mut self, input: impl Into<std::string::String>) -> Self {
            self.password = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_password(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.password = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateAs2BasicAuthInput`](crate::input::UpdateAs2BasicAuthInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateAs2BasicAuthInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateAs2BasicAuthInput {
                username: self.username,
                password: self.password,
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl UpdateAs2BasicAuthInput {
    /// Consumes the builder and constructs an Operation<[`UpdateAs2BasicAuth`](crate::operation::UpdateAs2BasicAuth)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateAs2BasicAuth,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateAs2BasicAuthInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_49 = &_input.partnership_id;
                let input_49 = input_49.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_49,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_50 = &_input.connection_id;
                let input_50 = input_50.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_50,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/as2/{connectionId}/basic-auth",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateAs2BasicAuthInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_as2_basic_auth(&self)?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateAs2BasicAuth::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateAs2BasicAuth",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateAs2BasicAuthInput`](crate::input::UpdateAs2BasicAuthInput).
    pub fn builder() -> crate::input::update_as2_basic_auth_input::Builder {
        crate::input::update_as2_basic_auth_input::Builder::default()
    }
}

/// See [`UpdateAs2ConnectionInput`](crate::input::UpdateAs2ConnectionInput).
pub mod update_as2_connection_input {

    /// A builder for [`UpdateAs2ConnectionInput`](crate::input::UpdateAs2ConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) local_as2_id: std::option::Option<std::string::String>,
        pub(crate) partner_as2_id: std::option::Option<std::string::String>,
        pub(crate) inbound_settings: std::option::Option<crate::model::As2InboundFields>,
        pub(crate) outbound_settings: std::option::Option<crate::model::As2OutboundFields>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) enabled: std::option::Option<bool>,
    }
    impl Builder {
        /// The name of the connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_as2_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.local_as2_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_as2_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.local_as2_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_as2_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partner_as2_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_as2_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partner_as2_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_settings(mut self, input: crate::model::As2InboundFields) -> Self {
            self.inbound_settings = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_settings(
            mut self,
            input: std::option::Option<crate::model::As2InboundFields>,
        ) -> Self {
            self.inbound_settings = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_settings(mut self, input: crate::model::As2OutboundFields) -> Self {
            self.outbound_settings = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_settings(
            mut self,
            input: std::option::Option<crate::model::As2OutboundFields>,
        ) -> Self {
            self.outbound_settings = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enabled(mut self, input: bool) -> Self {
            self.enabled = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.enabled = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateAs2ConnectionInput`](crate::input::UpdateAs2ConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateAs2ConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateAs2ConnectionInput {
                name: self.name,
                local_as2_id: self.local_as2_id,
                partner_as2_id: self.partner_as2_id,
                inbound_settings: self.inbound_settings,
                outbound_settings: self.outbound_settings,
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
                enabled: self.enabled,
            })
        }
    }
}
impl UpdateAs2ConnectionInput {
    /// Consumes the builder and constructs an Operation<[`UpdateAs2Connection`](crate::operation::UpdateAs2Connection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateAs2Connection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateAs2ConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_51 = &_input.partnership_id;
                let input_51 = input_51.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_51,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_52 = &_input.connection_id;
                let input_52 = input_52.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_52,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/as2/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateAs2ConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_as2_connection(&self)?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateAs2Connection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateAs2Connection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateAs2ConnectionInput`](crate::input::UpdateAs2ConnectionInput).
    pub fn builder() -> crate::input::update_as2_connection_input::Builder {
        crate::input::update_as2_connection_input::Builder::default()
    }
}

/// See [`UpdateAs2CredentialsInput`](crate::input::UpdateAs2CredentialsInput).
pub mod update_as2_credentials_input {

    /// A builder for [`UpdateAs2CredentialsInput`](crate::input::UpdateAs2CredentialsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) local_signing: std::option::Option<crate::model::As2LocalCertificate>,
        pub(crate) local_encryption: std::option::Option<crate::model::As2LocalCertificate>,
        pub(crate) partner_signing: std::option::Option<crate::model::As2PartnerCertificate>,
        pub(crate) partner_encryption: std::option::Option<crate::model::As2PartnerCertificate>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_signing(mut self, input: crate::model::As2LocalCertificate) -> Self {
            self.local_signing = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_signing(
            mut self,
            input: std::option::Option<crate::model::As2LocalCertificate>,
        ) -> Self {
            self.local_signing = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_encryption(mut self, input: crate::model::As2LocalCertificate) -> Self {
            self.local_encryption = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_encryption(
            mut self,
            input: std::option::Option<crate::model::As2LocalCertificate>,
        ) -> Self {
            self.local_encryption = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_signing(mut self, input: crate::model::As2PartnerCertificate) -> Self {
            self.partner_signing = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_signing(
            mut self,
            input: std::option::Option<crate::model::As2PartnerCertificate>,
        ) -> Self {
            self.partner_signing = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_encryption(mut self, input: crate::model::As2PartnerCertificate) -> Self {
            self.partner_encryption = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_encryption(
            mut self,
            input: std::option::Option<crate::model::As2PartnerCertificate>,
        ) -> Self {
            self.partner_encryption = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateAs2CredentialsInput`](crate::input::UpdateAs2CredentialsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateAs2CredentialsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateAs2CredentialsInput {
                local_signing: self.local_signing,
                local_encryption: self.local_encryption,
                partner_signing: self.partner_signing,
                partner_encryption: self.partner_encryption,
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl UpdateAs2CredentialsInput {
    /// Consumes the builder and constructs an Operation<[`UpdateAs2Credentials`](crate::operation::UpdateAs2Credentials)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateAs2Credentials,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateAs2CredentialsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_53 = &_input.partnership_id;
                let input_53 = input_53.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_53,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_54 = &_input.connection_id;
                let input_54 = input_54.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_54,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/as2/{connectionId}/credentials",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateAs2CredentialsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_as2_credentials(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateAs2Credentials::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateAs2Credentials",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateAs2CredentialsInput`](crate::input::UpdateAs2CredentialsInput).
    pub fn builder() -> crate::input::update_as2_credentials_input::Builder {
        crate::input::update_as2_credentials_input::Builder::default()
    }
}

/// See [`UpdateBucketConnectionInput`](crate::input::UpdateBucketConnectionInput).
pub mod update_bucket_connection_input {

    /// A builder for [`UpdateBucketConnectionInput`](crate::input::UpdateBucketConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) inbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) outbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) delete_inbound_files_on_receipt: std::option::Option<bool>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) enabled: std::option::Option<bool>,
    }
    impl Builder {
        /// The name of the connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.inbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.outbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn delete_inbound_files_on_receipt(mut self, input: bool) -> Self {
            self.delete_inbound_files_on_receipt = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_delete_inbound_files_on_receipt(
            mut self,
            input: std::option::Option<bool>,
        ) -> Self {
            self.delete_inbound_files_on_receipt = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enabled(mut self, input: bool) -> Self {
            self.enabled = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.enabled = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateBucketConnectionInput`](crate::input::UpdateBucketConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateBucketConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateBucketConnectionInput {
                name: self.name,
                inbound_subdirectory: self.inbound_subdirectory,
                outbound_subdirectory: self.outbound_subdirectory,
                delete_inbound_files_on_receipt: self.delete_inbound_files_on_receipt,
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
                enabled: self.enabled,
            })
        }
    }
}
impl UpdateBucketConnectionInput {
    /// Consumes the builder and constructs an Operation<[`UpdateBucketConnection`](crate::operation::UpdateBucketConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateBucketConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateBucketConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_55 = &_input.partnership_id;
                let input_55 = input_55.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_55,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_56 = &_input.connection_id;
                let input_56 = input_56.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_56,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/buckets/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateBucketConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_bucket_connection(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateBucketConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateBucketConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateBucketConnectionInput`](crate::input::UpdateBucketConnectionInput).
    pub fn builder() -> crate::input::update_bucket_connection_input::Builder {
        crate::input::update_bucket_connection_input::Builder::default()
    }
}

/// See [`UpdateGlobalConnectionInput`](crate::input::UpdateGlobalConnectionInput).
pub mod update_global_connection_input {

    /// A builder for [`UpdateGlobalConnectionInput`](crate::input::UpdateGlobalConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) enabled: std::option::Option<bool>,
    }
    impl Builder {
        /// The name of the global connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the global connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enabled(mut self, input: bool) -> Self {
            self.enabled = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.enabled = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateGlobalConnectionInput`](crate::input::UpdateGlobalConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateGlobalConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateGlobalConnectionInput {
                name: self.name,
                connection_id: self.connection_id,
                enabled: self.enabled,
            })
        }
    }
}
impl UpdateGlobalConnectionInput {
    /// Consumes the builder and constructs an Operation<[`UpdateGlobalConnection`](crate::operation::UpdateGlobalConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateGlobalConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateGlobalConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_57 = &_input.connection_id;
                let input_57 = input_57.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_57,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/global-connections/{connectionId}",
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateGlobalConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_global_connection(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateGlobalConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateGlobalConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateGlobalConnectionInput`](crate::input::UpdateGlobalConnectionInput).
    pub fn builder() -> crate::input::update_global_connection_input::Builder {
        crate::input::update_global_connection_input::Builder::default()
    }
}

/// See [`UpdateInboundX12TransactionSettingsInput`](crate::input::UpdateInboundX12TransactionSettingsInput).
pub mod update_inbound_x12_transaction_settings_input {

    /// A builder for [`UpdateInboundX12TransactionSettingsInput`](crate::input::UpdateInboundX12TransactionSettingsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) release: std::option::Option<std::string::String>,
        pub(crate) transaction_set_identifier: std::option::Option<std::string::String>,
        pub(crate) guide_id: std::option::Option<std::string::String>,
        pub(crate) enable_fragments: std::option::Option<bool>,
        pub(crate) fragment_size: std::option::Option<i32>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) inbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn release(mut self, input: impl Into<std::string::String>) -> Self {
            self.release = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_release(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.release = input;
            self
        }
        /// The X12 transaction set code, can include industry identifier.
        pub fn transaction_set_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.transaction_set_identifier = Some(input.into());
            self
        }
        /// The X12 transaction set code, can include industry identifier.
        pub fn set_transaction_set_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.transaction_set_identifier = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn guide_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.guide_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_guide_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.guide_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enable_fragments(mut self, input: bool) -> Self {
            self.enable_fragments = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enable_fragments(mut self, input: std::option::Option<bool>) -> Self {
            self.enable_fragments = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn fragment_size(mut self, input: i32) -> Self {
            self.fragment_size = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_fragment_size(mut self, input: std::option::Option<i32>) -> Self {
            self.fragment_size = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_x12_transaction_settings_id(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inbound_x12_transaction_settings_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_x12_transaction_settings_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_x12_transaction_settings_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateInboundX12TransactionSettingsInput`](crate::input::UpdateInboundX12TransactionSettingsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateInboundX12TransactionSettingsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateInboundX12TransactionSettingsInput {
                release: self.release,
                transaction_set_identifier: self.transaction_set_identifier,
                guide_id: self.guide_id,
                enable_fragments: self.enable_fragments,
                fragment_size: self.fragment_size,
                partnership_id: self.partnership_id,
                inbound_x12_transaction_settings_id: self.inbound_x12_transaction_settings_id,
            })
        }
    }
}
impl UpdateInboundX12TransactionSettingsInput {
    /// Consumes the builder and constructs an Operation<[`UpdateInboundX12TransactionSettings`](crate::operation::UpdateInboundX12TransactionSettings)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateInboundX12TransactionSettings,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateInboundX12TransactionSettingsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_58 = &_input.partnership_id;
                let input_58 = input_58.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_58,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_59 = &_input.inbound_x12_transaction_settings_id;
                let input_59 = input_59.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "inbound_x12_transaction_settings_id",
                        "cannot be empty or unset",
                    )
                })?;
                let inbound_x12_transaction_settings_id = aws_smithy_http::label::fmt_string(
                    input_59,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if inbound_x12_transaction_settings_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "inbound_x12_transaction_settings_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/partnerships/{partnershipId}/inbound-transactions/{inboundX12TransactionSettingsId}", partnershipId = partnership_id, inboundX12TransactionSettingsId = inbound_x12_transaction_settings_id).expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateInboundX12TransactionSettingsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_inbound_x12_transaction_settings(&self)?
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateInboundX12TransactionSettings::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateInboundX12TransactionSettings",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateInboundX12TransactionSettingsInput`](crate::input::UpdateInboundX12TransactionSettingsInput).
    pub fn builder() -> crate::input::update_inbound_x12_transaction_settings_input::Builder {
        crate::input::update_inbound_x12_transaction_settings_input::Builder::default()
    }
}

/// See [`UpdateOutboundX12TransactionSettingsInput`](crate::input::UpdateOutboundX12TransactionSettingsInput).
pub mod update_outbound_x12_transaction_settings_input {

    /// A builder for [`UpdateOutboundX12TransactionSettingsInput`](crate::input::UpdateOutboundX12TransactionSettingsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) release: std::option::Option<std::string::String>,
        pub(crate) transaction_set_identifier: std::option::Option<std::string::String>,
        pub(crate) guide_id: std::option::Option<std::string::String>,
        pub(crate) local_application_id: std::option::Option<std::string::String>,
        pub(crate) partner_application_id: std::option::Option<std::string::String>,
        pub(crate) connection: std::option::Option<crate::model::OutboundConnection>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) outbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn release(mut self, input: impl Into<std::string::String>) -> Self {
            self.release = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_release(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.release = input;
            self
        }
        /// The X12 transaction set code, can include industry identifier.
        pub fn transaction_set_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.transaction_set_identifier = Some(input.into());
            self
        }
        /// The X12 transaction set code, can include industry identifier.
        pub fn set_transaction_set_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.transaction_set_identifier = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn guide_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.guide_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_guide_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.guide_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_application_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.local_application_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_local_application_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.local_application_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_application_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partner_application_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_application_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partner_application_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn connection(mut self, input: crate::model::OutboundConnection) -> Self {
            self.connection = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_connection(
            mut self,
            input: std::option::Option<crate::model::OutboundConnection>,
        ) -> Self {
            self.connection = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_x12_transaction_settings_id(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.outbound_x12_transaction_settings_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_x12_transaction_settings_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_x12_transaction_settings_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateOutboundX12TransactionSettingsInput`](crate::input::UpdateOutboundX12TransactionSettingsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateOutboundX12TransactionSettingsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateOutboundX12TransactionSettingsInput {
                release: self.release,
                transaction_set_identifier: self.transaction_set_identifier,
                guide_id: self.guide_id,
                local_application_id: self.local_application_id,
                partner_application_id: self.partner_application_id,
                connection: self.connection,
                partnership_id: self.partnership_id,
                outbound_x12_transaction_settings_id: self.outbound_x12_transaction_settings_id,
            })
        }
    }
}
impl UpdateOutboundX12TransactionSettingsInput {
    /// Consumes the builder and constructs an Operation<[`UpdateOutboundX12TransactionSettings`](crate::operation::UpdateOutboundX12TransactionSettings)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateOutboundX12TransactionSettings,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateOutboundX12TransactionSettingsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_60 = &_input.partnership_id;
                let input_60 = input_60.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_60,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_61 = &_input.outbound_x12_transaction_settings_id;
                let input_61 = input_61.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "outbound_x12_transaction_settings_id",
                        "cannot be empty or unset",
                    )
                })?;
                let outbound_x12_transaction_settings_id = aws_smithy_http::label::fmt_string(
                    input_61,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if outbound_x12_transaction_settings_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "outbound_x12_transaction_settings_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/partnerships/{partnershipId}/outbound-transactions/{outboundX12TransactionSettingsId}", partnershipId = partnership_id, outboundX12TransactionSettingsId = outbound_x12_transaction_settings_id).expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateOutboundX12TransactionSettingsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_outbound_x12_transaction_settings(&self)?
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateOutboundX12TransactionSettings::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateOutboundX12TransactionSettings",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateOutboundX12TransactionSettingsInput`](crate::input::UpdateOutboundX12TransactionSettingsInput).
    pub fn builder() -> crate::input::update_outbound_x12_transaction_settings_input::Builder {
        crate::input::update_outbound_x12_transaction_settings_input::Builder::default()
    }
}

/// See [`UpdateRemoteFtpConnectionInput`](crate::input::UpdateRemoteFtpConnectionInput).
pub mod update_remote_ftp_connection_input {

    /// A builder for [`UpdateRemoteFtpConnectionInput`](crate::input::UpdateRemoteFtpConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) inbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) outbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) root_directory: std::option::Option<std::string::String>,
        pub(crate) host: std::option::Option<std::string::String>,
        pub(crate) username: std::option::Option<std::string::String>,
        pub(crate) port: std::option::Option<i32>,
        pub(crate) delete_after_retrieval: std::option::Option<bool>,
        pub(crate) ignore_file_timestamps: std::option::Option<bool>,
        pub(crate) enable_polling: std::option::Option<bool>,
        pub(crate) polling_interval: std::option::Option<i32>,
        pub(crate) polling_interval_unit: std::option::Option<crate::model::FtpIntervalUnit>,
        pub(crate) last_poll_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) retries: std::option::Option<i32>,
        pub(crate) ready_timeout: std::option::Option<i32>,
        pub(crate) timeout: std::option::Option<i32>,
        pub(crate) algorithms: std::option::Option<crate::model::RemoteFtpAlgorithms>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) enabled: std::option::Option<bool>,
    }
    impl Builder {
        /// The name of the connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.inbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.outbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_subdirectory = input;
            self
        }
        /// The root directory for this FTP connection
        pub fn root_directory(mut self, input: impl Into<std::string::String>) -> Self {
            self.root_directory = Some(input.into());
            self
        }
        /// The root directory for this FTP connection
        pub fn set_root_directory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.root_directory = input;
            self
        }
        /// The endpoint associated with the FTP connection
        pub fn host(mut self, input: impl Into<std::string::String>) -> Self {
            self.host = Some(input.into());
            self
        }
        /// The endpoint associated with the FTP connection
        pub fn set_host(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.host = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn username(mut self, input: impl Into<std::string::String>) -> Self {
            self.username = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_username(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.username = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn port(mut self, input: i32) -> Self {
            self.port = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_port(mut self, input: std::option::Option<i32>) -> Self {
            self.port = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn delete_after_retrieval(mut self, input: bool) -> Self {
            self.delete_after_retrieval = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_delete_after_retrieval(mut self, input: std::option::Option<bool>) -> Self {
            self.delete_after_retrieval = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn ignore_file_timestamps(mut self, input: bool) -> Self {
            self.ignore_file_timestamps = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_ignore_file_timestamps(mut self, input: std::option::Option<bool>) -> Self {
            self.ignore_file_timestamps = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enable_polling(mut self, input: bool) -> Self {
            self.enable_polling = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enable_polling(mut self, input: std::option::Option<bool>) -> Self {
            self.enable_polling = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn polling_interval(mut self, input: i32) -> Self {
            self.polling_interval = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_polling_interval(mut self, input: std::option::Option<i32>) -> Self {
            self.polling_interval = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn polling_interval_unit(mut self, input: crate::model::FtpIntervalUnit) -> Self {
            self.polling_interval_unit = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_polling_interval_unit(
            mut self,
            input: std::option::Option<crate::model::FtpIntervalUnit>,
        ) -> Self {
            self.polling_interval_unit = input;
            self
        }
        /// The timestamp when the last poll occurred
        pub fn last_poll_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.last_poll_at = Some(input);
            self
        }
        /// The timestamp when the last poll occurred
        pub fn set_last_poll_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.last_poll_at = input;
            self
        }
        /// Number of times to retry connecting
        pub fn retries(mut self, input: i32) -> Self {
            self.retries = Some(input);
            self
        }
        /// Number of times to retry connecting
        pub fn set_retries(mut self, input: std::option::Option<i32>) -> Self {
            self.retries = input;
            self
        }
        /// How long (in ms) to wait for the SSH handshake
        pub fn ready_timeout(mut self, input: i32) -> Self {
            self.ready_timeout = Some(input);
            self
        }
        /// How long (in ms) to wait for the SSH handshake
        pub fn set_ready_timeout(mut self, input: std::option::Option<i32>) -> Self {
            self.ready_timeout = input;
            self
        }
        /// The underlying socket timeout in ms. Default: none
        pub fn timeout(mut self, input: i32) -> Self {
            self.timeout = Some(input);
            self
        }
        /// The underlying socket timeout in ms. Default: none
        pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
            self.timeout = input;
            self
        }
        /// Explicit overrides for the default transport layer algorithms used for the connection
        pub fn algorithms(mut self, input: crate::model::RemoteFtpAlgorithms) -> Self {
            self.algorithms = Some(input);
            self
        }
        /// Explicit overrides for the default transport layer algorithms used for the connection
        pub fn set_algorithms(
            mut self,
            input: std::option::Option<crate::model::RemoteFtpAlgorithms>,
        ) -> Self {
            self.algorithms = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enabled(mut self, input: bool) -> Self {
            self.enabled = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.enabled = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateRemoteFtpConnectionInput`](crate::input::UpdateRemoteFtpConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateRemoteFtpConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateRemoteFtpConnectionInput {
                name: self.name,
                inbound_subdirectory: self.inbound_subdirectory,
                outbound_subdirectory: self.outbound_subdirectory,
                root_directory: self.root_directory,
                host: self.host,
                username: self.username,
                port: self.port,
                delete_after_retrieval: self.delete_after_retrieval,
                ignore_file_timestamps: self.ignore_file_timestamps,
                enable_polling: self.enable_polling,
                polling_interval: self.polling_interval,
                polling_interval_unit: self.polling_interval_unit,
                last_poll_at: self.last_poll_at,
                retries: self.retries,
                ready_timeout: self.ready_timeout,
                timeout: self.timeout,
                algorithms: self.algorithms,
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
                enabled: self.enabled,
            })
        }
    }
}
impl UpdateRemoteFtpConnectionInput {
    /// Consumes the builder and constructs an Operation<[`UpdateRemoteFtpConnection`](crate::operation::UpdateRemoteFtpConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateRemoteFtpConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateRemoteFtpConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_62 = &_input.partnership_id;
                let input_62 = input_62.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_62,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_63 = &_input.connection_id;
                let input_63 = input_63.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_63,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/remote-ftp/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateRemoteFtpConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_remote_ftp_connection(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateRemoteFtpConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateRemoteFtpConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateRemoteFtpConnectionInput`](crate::input::UpdateRemoteFtpConnectionInput).
    pub fn builder() -> crate::input::update_remote_ftp_connection_input::Builder {
        crate::input::update_remote_ftp_connection_input::Builder::default()
    }
}

/// See [`UpdateRemoteFtpCredentialsInput`](crate::input::UpdateRemoteFtpCredentialsInput).
pub mod update_remote_ftp_credentials_input {

    /// A builder for [`UpdateRemoteFtpCredentialsInput`](crate::input::UpdateRemoteFtpCredentialsInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) password: std::option::Option<std::string::String>,
        pub(crate) private_key: std::option::Option<std::string::String>,
        pub(crate) passphrase: std::option::Option<std::string::String>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn password(mut self, input: impl Into<std::string::String>) -> Self {
            self.password = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_password(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.password = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn private_key(mut self, input: impl Into<std::string::String>) -> Self {
            self.private_key = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_private_key(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.private_key = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn passphrase(mut self, input: impl Into<std::string::String>) -> Self {
            self.passphrase = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_passphrase(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.passphrase = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateRemoteFtpCredentialsInput`](crate::input::UpdateRemoteFtpCredentialsInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateRemoteFtpCredentialsInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateRemoteFtpCredentialsInput {
                password: self.password,
                private_key: self.private_key,
                passphrase: self.passphrase,
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
            })
        }
    }
}
impl UpdateRemoteFtpCredentialsInput {
    /// Consumes the builder and constructs an Operation<[`UpdateRemoteFtpCredentials`](crate::operation::UpdateRemoteFtpCredentials)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateRemoteFtpCredentials,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateRemoteFtpCredentialsInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_64 = &_input.partnership_id;
                let input_64 = input_64.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_64,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_65 = &_input.connection_id;
                let input_65 = input_65.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_65,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/partnerships/{partnershipId}/connections/remote-ftp/{connectionId}/credentials", partnershipId = partnership_id, connectionId = connection_id).expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateRemoteFtpCredentialsInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_remote_ftp_credentials(&self)?
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateRemoteFtpCredentials::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateRemoteFtpCredentials",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateRemoteFtpCredentialsInput`](crate::input::UpdateRemoteFtpCredentialsInput).
    pub fn builder() -> crate::input::update_remote_ftp_credentials_input::Builder {
        crate::input::update_remote_ftp_credentials_input::Builder::default()
    }
}

/// See [`UpdateStediFtpConnectionInput`](crate::input::UpdateStediFtpConnectionInput).
pub mod update_stedi_ftp_connection_input {

    /// A builder for [`UpdateStediFtpConnectionInput`](crate::input::UpdateStediFtpConnectionInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) inbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) outbound_subdirectory: std::option::Option<std::string::String>,
        pub(crate) delete_inbound_files_on_receipt: std::option::Option<bool>,
        pub(crate) username: std::option::Option<std::string::String>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) enabled: std::option::Option<bool>,
    }
    impl Builder {
        /// The name of the connection
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the connection
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn inbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.inbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_inbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn outbound_subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.outbound_subdirectory = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_outbound_subdirectory(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.outbound_subdirectory = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn delete_inbound_files_on_receipt(mut self, input: bool) -> Self {
            self.delete_inbound_files_on_receipt = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_delete_inbound_files_on_receipt(
            mut self,
            input: std::option::Option<bool>,
        ) -> Self {
            self.delete_inbound_files_on_receipt = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn username(mut self, input: impl Into<std::string::String>) -> Self {
            self.username = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_username(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.username = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Autogenerated identifier for a connection
        pub fn connection_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.connection_id = Some(input.into());
            self
        }
        /// Autogenerated identifier for a connection
        pub fn set_connection_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.connection_id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn enabled(mut self, input: bool) -> Self {
            self.enabled = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.enabled = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateStediFtpConnectionInput`](crate::input::UpdateStediFtpConnectionInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateStediFtpConnectionInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateStediFtpConnectionInput {
                name: self.name,
                inbound_subdirectory: self.inbound_subdirectory,
                outbound_subdirectory: self.outbound_subdirectory,
                delete_inbound_files_on_receipt: self.delete_inbound_files_on_receipt,
                username: self.username,
                partnership_id: self.partnership_id,
                connection_id: self.connection_id,
                enabled: self.enabled,
            })
        }
    }
}
impl UpdateStediFtpConnectionInput {
    /// Consumes the builder and constructs an Operation<[`UpdateStediFtpConnection`](crate::operation::UpdateStediFtpConnection)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateStediFtpConnection,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateStediFtpConnectionInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_66 = &_input.partnership_id;
                let input_66 = input_66.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_66,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                let input_67 = &_input.connection_id;
                let input_67 = input_67.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "connection_id",
                        "cannot be empty or unset",
                    )
                })?;
                let connection_id = aws_smithy_http::label::fmt_string(
                    input_67,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if connection_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "connection_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}/connections/stedi-ftp/{connectionId}",
                    partnershipId = partnership_id,
                    connectionId = connection_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateStediFtpConnectionInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_stedi_ftp_connection(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateStediFtpConnection::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateStediFtpConnection",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateStediFtpConnectionInput`](crate::input::UpdateStediFtpConnectionInput).
    pub fn builder() -> crate::input::update_stedi_ftp_connection_input::Builder {
        crate::input::update_stedi_ftp_connection_input::Builder::default()
    }
}

/// See [`UpdateX12PartnershipInput`](crate::input::UpdateX12PartnershipInput).
pub mod update_x12_partnership_input {

    /// A builder for [`UpdateX12PartnershipInput`](crate::input::UpdateX12PartnershipInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) interchange_usage_indicator:
            std::option::Option<crate::model::X12UsageIndicator>,
        pub(crate) timezone: std::option::Option<crate::model::Timezone>,
        pub(crate) time_format: std::option::Option<crate::model::X12TimeFormat>,
        pub(crate) ack_configuration:
            std::option::Option<crate::model::X12PartnershipAckConfiguration>,
        pub(crate) partnership_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn interchange_usage_indicator(
            mut self,
            input: crate::model::X12UsageIndicator,
        ) -> Self {
            self.interchange_usage_indicator = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_interchange_usage_indicator(
            mut self,
            input: std::option::Option<crate::model::X12UsageIndicator>,
        ) -> Self {
            self.interchange_usage_indicator = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn timezone(mut self, input: crate::model::Timezone) -> Self {
            self.timezone = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_timezone(mut self, input: std::option::Option<crate::model::Timezone>) -> Self {
            self.timezone = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn time_format(mut self, input: crate::model::X12TimeFormat) -> Self {
            self.time_format = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_time_format(
            mut self,
            input: std::option::Option<crate::model::X12TimeFormat>,
        ) -> Self {
            self.time_format = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn ack_configuration(
            mut self,
            input: crate::model::X12PartnershipAckConfiguration,
        ) -> Self {
            self.ack_configuration = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_ack_configuration(
            mut self,
            input: std::option::Option<crate::model::X12PartnershipAckConfiguration>,
        ) -> Self {
            self.ack_configuration = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partnership_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.partnership_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partnership_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partnership_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateX12PartnershipInput`](crate::input::UpdateX12PartnershipInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateX12PartnershipInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateX12PartnershipInput {
                interchange_usage_indicator: self.interchange_usage_indicator,
                timezone: self.timezone,
                time_format: self.time_format,
                ack_configuration: self.ack_configuration,
                partnership_id: self.partnership_id,
            })
        }
    }
}
impl UpdateX12PartnershipInput {
    /// Consumes the builder and constructs an Operation<[`UpdateX12Partnership`](crate::operation::UpdateX12Partnership)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateX12Partnership,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateX12PartnershipInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_68 = &_input.partnership_id;
                let input_68 = input_68.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "partnership_id",
                        "cannot be empty or unset",
                    )
                })?;
                let partnership_id = aws_smithy_http::label::fmt_string(
                    input_68,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if partnership_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "partnership_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(
                    output,
                    "/x12/partnerships/{partnershipId}",
                    partnershipId = partnership_id
                )
                .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateX12PartnershipInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_x12_partnership(
                &self,
            )?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateX12Partnership::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateX12Partnership",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateX12PartnershipInput`](crate::input::UpdateX12PartnershipInput).
    pub fn builder() -> crate::input::update_x12_partnership_input::Builder {
        crate::input::update_x12_partnership_input::Builder::default()
    }
}

/// See [`UpdateX12ProfileInput`](crate::input::UpdateX12ProfileInput).
pub mod update_x12_profile_input {

    /// A builder for [`UpdateX12ProfileInput`](crate::input::UpdateX12ProfileInput).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) application_identifiers:
            std::option::Option<std::vec::Vec<crate::model::X12ApplicationId>>,
        pub(crate) profile_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `application_identifiers`.
        ///
        /// To override the contents of this collection use [`set_application_identifiers`](Self::set_application_identifiers).
        ///
        /// Store the application ids provided by your partner, with the ability to select one as the default. These values can be used to configure the GS-02, GS-03 of the outbound transaction settings.
        pub fn application_identifiers(mut self, input: crate::model::X12ApplicationId) -> Self {
            let mut v = self.application_identifiers.unwrap_or_default();
            v.push(input);
            self.application_identifiers = Some(v);
            self
        }
        /// Store the application ids provided by your partner, with the ability to select one as the default. These values can be used to configure the GS-02, GS-03 of the outbound transaction settings.
        pub fn set_application_identifiers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::X12ApplicationId>>,
        ) -> Self {
            self.application_identifiers = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn profile_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.profile_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_profile_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.profile_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateX12ProfileInput`](crate::input::UpdateX12ProfileInput).
        pub fn build(
            self,
        ) -> Result<
            crate::input::UpdateX12ProfileInput,
            aws_smithy_http::operation::error::BuildError,
        > {
            Ok(crate::input::UpdateX12ProfileInput {
                application_identifiers: self.application_identifiers,
                profile_id: self.profile_id,
            })
        }
    }
}
impl UpdateX12ProfileInput {
    /// Consumes the builder and constructs an Operation<[`UpdateX12Profile`](crate::operation::UpdateX12Profile)>
    #[allow(unused_mut)]
    #[allow(clippy::let_and_return)]
    #[allow(clippy::needless_borrow)]
    pub async fn make_operation(
        &self,
        _config: &crate::config::Config,
    ) -> std::result::Result<
        aws_smithy_http::operation::Operation<
            crate::operation::UpdateX12Profile,
            aws_http::retry::AwsResponseRetryClassifier,
        >,
        aws_smithy_http::operation::error::BuildError,
    > {
        let params_result = crate::endpoint::Params::builder()
            .set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
            .set_endpoint(_config.endpoint_url.clone())
            .set_stage(_config.stage.clone())
            .build()
            .map_err(|err| {
                aws_smithy_http::endpoint::ResolveEndpointError::from_source(
                    "could not construct endpoint parameters",
                    err,
                )
            });
        let (endpoint_result, params) = match params_result {
            Ok(params) => (
                _config.endpoint_resolver.resolve_endpoint(&params),
                Some(params),
            ),
            Err(e) => (Err(e), None),
        };
        let mut request = {
            fn uri_base(
                _input: &crate::input::UpdateX12ProfileInput,
                output: &mut String,
            ) -> Result<(), aws_smithy_http::operation::error::BuildError> {
                let input_69 = &_input.profile_id;
                let input_69 = input_69.as_ref().ok_or_else(|| {
                    aws_smithy_http::operation::error::BuildError::missing_field(
                        "profile_id",
                        "cannot be empty or unset",
                    )
                })?;
                let profile_id = aws_smithy_http::label::fmt_string(
                    input_69,
                    aws_smithy_http::label::EncodingStrategy::Default,
                );
                if profile_id.is_empty() {
                    return Err(
                        aws_smithy_http::operation::error::BuildError::missing_field(
                            "profile_id",
                            "cannot be empty or unset",
                        ),
                    );
                }
                write!(output, "/x12/profiles/{profileId}", profileId = profile_id)
                    .expect("formatting should succeed");
                Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::input::UpdateX12ProfileInput,
                builder: http::request::Builder,
            ) -> std::result::Result<
                http::request::Builder,
                aws_smithy_http::operation::error::BuildError,
            > {
                let mut uri = String::new();
                uri_base(input, &mut uri)?;
                Ok(builder.method("PUT").uri(uri))
            }
            let mut builder = update_http_builder(&self, http::request::Builder::new())?;
            builder = aws_smithy_http::header::set_request_header_if_absent(
                builder,
                http::header::CONTENT_TYPE,
                "application/json",
            );
            builder
        };
        let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
        #[allow(clippy::useless_conversion)]
        let body = aws_smithy_http::body::SdkBody::from(
            crate::operation_ser::serialize_operation_crate_operation_update_x12_profile(&self)?,
        );
        if let Some(content_length) = body.content_length() {
            request = aws_smithy_http::header::set_request_header_if_absent(
                request,
                http::header::CONTENT_LENGTH,
                content_length,
            );
        }
        let request = request.body(body).expect("should be valid request");
        let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
        if let Some(api_key_config) = _config.api_key() {
            request.properties_mut().insert(api_key_config.clone());
            let api_key = api_key_config.api_key();
            let auth_definition = aws_smithy_http_auth::definition::HttpAuthDefinition::header(
                "Authorization".to_owned(),
                Some("Key".to_owned()),
            );
            let name = auth_definition.name();
            let value = match auth_definition.scheme() {
                Some(value) => format!("{value} {api_key}"),
                None => api_key.to_owned(),
            };
            request.http_mut().headers_mut().insert(
                http::header::HeaderName::from_bytes(name.as_bytes())
                    .expect("valid header name for api key auth"),
                http::header::HeaderValue::from_bytes(value.as_bytes())
                    .expect("valid header value for api key auth"),
            );
        }
        request.properties_mut().insert(endpoint_result);
        if let Some(params) = params {
            request.properties_mut().insert(params);
        }
        request
            .properties_mut()
            .insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
        let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
            aws_types::os_shim_internal::Env::real(),
            crate::API_METADATA.clone(),
        );
        if let Some(app_name) = _config.app_name() {
            user_agent = user_agent.with_app_name(app_name.clone());
        }
        request.properties_mut().insert(user_agent);
        if let Some(region) = &_config.region {
            request.properties_mut().insert(region.clone());
        }
        let op = aws_smithy_http::operation::Operation::new(
            request,
            crate::operation::UpdateX12Profile::new(),
        )
        .with_metadata(aws_smithy_http::operation::Metadata::new(
            "UpdateX12Profile",
            "partners",
        ));
        let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
        Ok(op)
    }
    /// Creates a new builder-style object to manufacture [`UpdateX12ProfileInput`](crate::input::UpdateX12ProfileInput).
    pub fn builder() -> crate::input::update_x12_profile_input::Builder {
        crate::input::update_x12_profile_input::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListX12ProfilesInput {
    /// The maximum number of elements to return in a page
    #[doc(hidden)]
    pub page_size: std::option::Option<i32>,
    /// The token used for pagination
    #[doc(hidden)]
    pub page_token: std::option::Option<std::string::String>,
}
impl ListX12ProfilesInput {
    /// The maximum number of elements to return in a page
    pub fn page_size(&self) -> std::option::Option<i32> {
        self.page_size
    }
    /// The token used for pagination
    pub fn page_token(&self) -> std::option::Option<&str> {
        self.page_token.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateX12ProfileInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub interchange_qualifier: std::option::Option<crate::model::X12InterchangeQualifier>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub interchange_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub profile_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub profile_type: std::option::Option<crate::model::ProfileType>,
    /// Store the application ids provided by your partner, with the ability to select one as the default. These values can be used to configure the GS-02, GS-03 of the outbound transaction settings.
    #[doc(hidden)]
    pub application_identifiers: std::option::Option<std::vec::Vec<crate::model::X12ApplicationId>>,
}
impl CreateX12ProfileInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn interchange_qualifier(
        &self,
    ) -> std::option::Option<&crate::model::X12InterchangeQualifier> {
        self.interchange_qualifier.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn interchange_id(&self) -> std::option::Option<&str> {
        self.interchange_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn profile_id(&self) -> std::option::Option<&str> {
        self.profile_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn profile_type(&self) -> std::option::Option<&crate::model::ProfileType> {
        self.profile_type.as_ref()
    }
    /// Store the application ids provided by your partner, with the ability to select one as the default. These values can be used to configure the GS-02, GS-03 of the outbound transaction settings.
    pub fn application_identifiers(
        &self,
    ) -> std::option::Option<&[crate::model::X12ApplicationId]> {
        self.application_identifiers.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteX12ProfileInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub profile_id: std::option::Option<std::string::String>,
}
impl DeleteX12ProfileInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn profile_id(&self) -> std::option::Option<&str> {
        self.profile_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateX12ProfileInput {
    /// Store the application ids provided by your partner, with the ability to select one as the default. These values can be used to configure the GS-02, GS-03 of the outbound transaction settings.
    #[doc(hidden)]
    pub application_identifiers: std::option::Option<std::vec::Vec<crate::model::X12ApplicationId>>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub profile_id: std::option::Option<std::string::String>,
}
impl UpdateX12ProfileInput {
    /// Store the application ids provided by your partner, with the ability to select one as the default. These values can be used to configure the GS-02, GS-03 of the outbound transaction settings.
    pub fn application_identifiers(
        &self,
    ) -> std::option::Option<&[crate::model::X12ApplicationId]> {
        self.application_identifiers.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn profile_id(&self) -> std::option::Option<&str> {
        self.profile_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetX12ProfileInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub profile_id: std::option::Option<std::string::String>,
}
impl GetX12ProfileInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn profile_id(&self) -> std::option::Option<&str> {
        self.profile_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListX12PartnershipsInput {
    /// The maximum number of elements to return in a page
    #[doc(hidden)]
    pub page_size: std::option::Option<i32>,
    /// The token used for pagination
    #[doc(hidden)]
    pub page_token: std::option::Option<std::string::String>,
}
impl ListX12PartnershipsInput {
    /// The maximum number of elements to return in a page
    pub fn page_size(&self) -> std::option::Option<i32> {
        self.page_size
    }
    /// The token used for pagination
    pub fn page_token(&self) -> std::option::Option<&str> {
        self.page_token.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateX12PartnershipInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_profile_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_profile_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub interchange_usage_indicator: std::option::Option<crate::model::X12UsageIndicator>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub timezone: std::option::Option<crate::model::Timezone>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub time_format: std::option::Option<crate::model::X12TimeFormat>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub ack_configuration: std::option::Option<crate::model::X12PartnershipAckConfiguration>,
}
impl CreateX12PartnershipInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_profile_id(&self) -> std::option::Option<&str> {
        self.local_profile_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_profile_id(&self) -> std::option::Option<&str> {
        self.partner_profile_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn interchange_usage_indicator(
        &self,
    ) -> std::option::Option<&crate::model::X12UsageIndicator> {
        self.interchange_usage_indicator.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn timezone(&self) -> std::option::Option<&crate::model::Timezone> {
        self.timezone.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn time_format(&self) -> std::option::Option<&crate::model::X12TimeFormat> {
        self.time_format.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn ack_configuration(
        &self,
    ) -> std::option::Option<&crate::model::X12PartnershipAckConfiguration> {
        self.ack_configuration.as_ref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteX12PartnershipInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl DeleteX12PartnershipInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateX12PartnershipInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub interchange_usage_indicator: std::option::Option<crate::model::X12UsageIndicator>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub timezone: std::option::Option<crate::model::Timezone>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub time_format: std::option::Option<crate::model::X12TimeFormat>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub ack_configuration: std::option::Option<crate::model::X12PartnershipAckConfiguration>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl UpdateX12PartnershipInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn interchange_usage_indicator(
        &self,
    ) -> std::option::Option<&crate::model::X12UsageIndicator> {
        self.interchange_usage_indicator.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn timezone(&self) -> std::option::Option<&crate::model::Timezone> {
        self.timezone.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn time_format(&self) -> std::option::Option<&crate::model::X12TimeFormat> {
        self.time_format.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn ack_configuration(
        &self,
    ) -> std::option::Option<&crate::model::X12PartnershipAckConfiguration> {
        self.ack_configuration.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetX12PartnershipInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl GetX12PartnershipInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateStediFtpConnectionInput {
    /// The name of the connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub delete_inbound_files_on_receipt: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub username: std::option::Option<std::string::String>,
    /// The stedi SFTP bucket name
    #[doc(hidden)]
    pub bucket_name: std::option::Option<std::string::String>,
    /// The home directory for this SFTP connection
    #[doc(hidden)]
    pub home_directory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl CreateStediFtpConnectionInput {
    /// The name of the connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_subdirectory(&self) -> std::option::Option<&str> {
        self.inbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_subdirectory(&self) -> std::option::Option<&str> {
        self.outbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn delete_inbound_files_on_receipt(&self) -> std::option::Option<bool> {
        self.delete_inbound_files_on_receipt
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn username(&self) -> std::option::Option<&str> {
        self.username.as_deref()
    }
    /// The stedi SFTP bucket name
    pub fn bucket_name(&self) -> std::option::Option<&str> {
        self.bucket_name.as_deref()
    }
    /// The home directory for this SFTP connection
    pub fn home_directory(&self) -> std::option::Option<&str> {
        self.home_directory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteStediFtpConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl DeleteStediFtpConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateStediFtpConnectionInput {
    /// The name of the connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub delete_inbound_files_on_receipt: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub username: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl UpdateStediFtpConnectionInput {
    /// The name of the connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_subdirectory(&self) -> std::option::Option<&str> {
        self.inbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_subdirectory(&self) -> std::option::Option<&str> {
        self.outbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn delete_inbound_files_on_receipt(&self) -> std::option::Option<bool> {
        self.delete_inbound_files_on_receipt
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn username(&self) -> std::option::Option<&str> {
        self.username.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetStediFtpConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl GetStediFtpConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateRemoteFtpCredentialsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub password: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub private_key: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub passphrase: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl UpdateRemoteFtpCredentialsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn password(&self) -> std::option::Option<&str> {
        self.password.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn private_key(&self) -> std::option::Option<&str> {
        self.private_key.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn passphrase(&self) -> std::option::Option<&str> {
        self.passphrase.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateRemoteFtpConnectionInput {
    /// The name of the connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_subdirectory: std::option::Option<std::string::String>,
    /// The root directory for this FTP connection
    #[doc(hidden)]
    pub root_directory: std::option::Option<std::string::String>,
    /// The endpoint associated with the FTP connection
    #[doc(hidden)]
    pub host: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub username: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub port: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub delete_after_retrieval: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub ignore_file_timestamps: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enable_polling: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub polling_interval: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub polling_interval_unit: std::option::Option<crate::model::FtpIntervalUnit>,
    /// The timestamp when the last poll occurred
    #[doc(hidden)]
    pub last_poll_at: std::option::Option<aws_smithy_types::DateTime>,
    /// Number of times to retry connecting
    #[doc(hidden)]
    pub retries: std::option::Option<i32>,
    /// How long (in ms) to wait for the SSH handshake
    #[doc(hidden)]
    pub ready_timeout: std::option::Option<i32>,
    /// The underlying socket timeout in ms. Default: none
    #[doc(hidden)]
    pub timeout: std::option::Option<i32>,
    /// Explicit overrides for the default transport layer algorithms used for the connection
    #[doc(hidden)]
    pub algorithms: std::option::Option<crate::model::RemoteFtpAlgorithms>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub password: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub private_key: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub passphrase: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl CreateRemoteFtpConnectionInput {
    /// The name of the connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_subdirectory(&self) -> std::option::Option<&str> {
        self.inbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_subdirectory(&self) -> std::option::Option<&str> {
        self.outbound_subdirectory.as_deref()
    }
    /// The root directory for this FTP connection
    pub fn root_directory(&self) -> std::option::Option<&str> {
        self.root_directory.as_deref()
    }
    /// The endpoint associated with the FTP connection
    pub fn host(&self) -> std::option::Option<&str> {
        self.host.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn username(&self) -> std::option::Option<&str> {
        self.username.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn port(&self) -> std::option::Option<i32> {
        self.port
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn delete_after_retrieval(&self) -> std::option::Option<bool> {
        self.delete_after_retrieval
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn ignore_file_timestamps(&self) -> std::option::Option<bool> {
        self.ignore_file_timestamps
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enable_polling(&self) -> std::option::Option<bool> {
        self.enable_polling
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn polling_interval(&self) -> std::option::Option<i32> {
        self.polling_interval
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn polling_interval_unit(&self) -> std::option::Option<&crate::model::FtpIntervalUnit> {
        self.polling_interval_unit.as_ref()
    }
    /// The timestamp when the last poll occurred
    pub fn last_poll_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.last_poll_at.as_ref()
    }
    /// Number of times to retry connecting
    pub fn retries(&self) -> std::option::Option<i32> {
        self.retries
    }
    /// How long (in ms) to wait for the SSH handshake
    pub fn ready_timeout(&self) -> std::option::Option<i32> {
        self.ready_timeout
    }
    /// The underlying socket timeout in ms. Default: none
    pub fn timeout(&self) -> std::option::Option<i32> {
        self.timeout
    }
    /// Explicit overrides for the default transport layer algorithms used for the connection
    pub fn algorithms(&self) -> std::option::Option<&crate::model::RemoteFtpAlgorithms> {
        self.algorithms.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn password(&self) -> std::option::Option<&str> {
        self.password.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn private_key(&self) -> std::option::Option<&str> {
        self.private_key.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn passphrase(&self) -> std::option::Option<&str> {
        self.passphrase.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteRemoteFtpConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl DeleteRemoteFtpConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateRemoteFtpConnectionInput {
    /// The name of the connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_subdirectory: std::option::Option<std::string::String>,
    /// The root directory for this FTP connection
    #[doc(hidden)]
    pub root_directory: std::option::Option<std::string::String>,
    /// The endpoint associated with the FTP connection
    #[doc(hidden)]
    pub host: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub username: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub port: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub delete_after_retrieval: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub ignore_file_timestamps: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enable_polling: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub polling_interval: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub polling_interval_unit: std::option::Option<crate::model::FtpIntervalUnit>,
    /// The timestamp when the last poll occurred
    #[doc(hidden)]
    pub last_poll_at: std::option::Option<aws_smithy_types::DateTime>,
    /// Number of times to retry connecting
    #[doc(hidden)]
    pub retries: std::option::Option<i32>,
    /// How long (in ms) to wait for the SSH handshake
    #[doc(hidden)]
    pub ready_timeout: std::option::Option<i32>,
    /// The underlying socket timeout in ms. Default: none
    #[doc(hidden)]
    pub timeout: std::option::Option<i32>,
    /// Explicit overrides for the default transport layer algorithms used for the connection
    #[doc(hidden)]
    pub algorithms: std::option::Option<crate::model::RemoteFtpAlgorithms>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl UpdateRemoteFtpConnectionInput {
    /// The name of the connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_subdirectory(&self) -> std::option::Option<&str> {
        self.inbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_subdirectory(&self) -> std::option::Option<&str> {
        self.outbound_subdirectory.as_deref()
    }
    /// The root directory for this FTP connection
    pub fn root_directory(&self) -> std::option::Option<&str> {
        self.root_directory.as_deref()
    }
    /// The endpoint associated with the FTP connection
    pub fn host(&self) -> std::option::Option<&str> {
        self.host.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn username(&self) -> std::option::Option<&str> {
        self.username.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn port(&self) -> std::option::Option<i32> {
        self.port
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn delete_after_retrieval(&self) -> std::option::Option<bool> {
        self.delete_after_retrieval
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn ignore_file_timestamps(&self) -> std::option::Option<bool> {
        self.ignore_file_timestamps
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enable_polling(&self) -> std::option::Option<bool> {
        self.enable_polling
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn polling_interval(&self) -> std::option::Option<i32> {
        self.polling_interval
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn polling_interval_unit(&self) -> std::option::Option<&crate::model::FtpIntervalUnit> {
        self.polling_interval_unit.as_ref()
    }
    /// The timestamp when the last poll occurred
    pub fn last_poll_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.last_poll_at.as_ref()
    }
    /// Number of times to retry connecting
    pub fn retries(&self) -> std::option::Option<i32> {
        self.retries
    }
    /// How long (in ms) to wait for the SSH handshake
    pub fn ready_timeout(&self) -> std::option::Option<i32> {
        self.ready_timeout
    }
    /// The underlying socket timeout in ms. Default: none
    pub fn timeout(&self) -> std::option::Option<i32> {
        self.timeout
    }
    /// Explicit overrides for the default transport layer algorithms used for the connection
    pub fn algorithms(&self) -> std::option::Option<&crate::model::RemoteFtpAlgorithms> {
        self.algorithms.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetRemoteFtpConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl GetRemoteFtpConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateOutboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub release: std::option::Option<std::string::String>,
    /// The X12 transaction set code, can include industry identifier.
    #[doc(hidden)]
    pub transaction_set_identifier: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub guide_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_application_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_application_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub connection: std::option::Option<crate::model::OutboundConnection>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl CreateOutboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn release(&self) -> std::option::Option<&str> {
        self.release.as_deref()
    }
    /// The X12 transaction set code, can include industry identifier.
    pub fn transaction_set_identifier(&self) -> std::option::Option<&str> {
        self.transaction_set_identifier.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn guide_id(&self) -> std::option::Option<&str> {
        self.guide_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_application_id(&self) -> std::option::Option<&str> {
        self.local_application_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_application_id(&self) -> std::option::Option<&str> {
        self.partner_application_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn connection(&self) -> std::option::Option<&crate::model::OutboundConnection> {
        self.connection.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_x12_transaction_settings_id(&self) -> std::option::Option<&str> {
        self.outbound_x12_transaction_settings_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteOutboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
}
impl DeleteOutboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_x12_transaction_settings_id(&self) -> std::option::Option<&str> {
        self.outbound_x12_transaction_settings_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateOutboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub release: std::option::Option<std::string::String>,
    /// The X12 transaction set code, can include industry identifier.
    #[doc(hidden)]
    pub transaction_set_identifier: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub guide_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_application_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_application_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub connection: std::option::Option<crate::model::OutboundConnection>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
}
impl UpdateOutboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn release(&self) -> std::option::Option<&str> {
        self.release.as_deref()
    }
    /// The X12 transaction set code, can include industry identifier.
    pub fn transaction_set_identifier(&self) -> std::option::Option<&str> {
        self.transaction_set_identifier.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn guide_id(&self) -> std::option::Option<&str> {
        self.guide_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_application_id(&self) -> std::option::Option<&str> {
        self.local_application_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_application_id(&self) -> std::option::Option<&str> {
        self.partner_application_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn connection(&self) -> std::option::Option<&crate::model::OutboundConnection> {
        self.connection.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_x12_transaction_settings_id(&self) -> std::option::Option<&str> {
        self.outbound_x12_transaction_settings_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetOutboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
}
impl GetOutboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_x12_transaction_settings_id(&self) -> std::option::Option<&str> {
        self.outbound_x12_transaction_settings_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetOutboundX12ControlNumbersInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl GetOutboundX12ControlNumbersInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SetOutboundX12ControlNumberInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub x12_control_number: std::option::Option<i64>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub control_number_type: std::option::Option<crate::model::X12ControlNumberType>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl SetOutboundX12ControlNumberInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn x12_control_number(&self) -> std::option::Option<i64> {
        self.x12_control_number
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn control_number_type(&self) -> std::option::Option<&crate::model::X12ControlNumberType> {
        self.control_number_type.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateInboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub release: std::option::Option<std::string::String>,
    /// The X12 transaction set code, can include industry identifier.
    #[doc(hidden)]
    pub transaction_set_identifier: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub guide_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enable_fragments: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub fragment_size: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl CreateInboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn release(&self) -> std::option::Option<&str> {
        self.release.as_deref()
    }
    /// The X12 transaction set code, can include industry identifier.
    pub fn transaction_set_identifier(&self) -> std::option::Option<&str> {
        self.transaction_set_identifier.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn guide_id(&self) -> std::option::Option<&str> {
        self.guide_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enable_fragments(&self) -> std::option::Option<bool> {
        self.enable_fragments
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn fragment_size(&self) -> std::option::Option<i32> {
        self.fragment_size
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteInboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
}
impl DeleteInboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_x12_transaction_settings_id(&self) -> std::option::Option<&str> {
        self.inbound_x12_transaction_settings_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateInboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub release: std::option::Option<std::string::String>,
    /// The X12 transaction set code, can include industry identifier.
    #[doc(hidden)]
    pub transaction_set_identifier: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub guide_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enable_fragments: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub fragment_size: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
}
impl UpdateInboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn release(&self) -> std::option::Option<&str> {
        self.release.as_deref()
    }
    /// The X12 transaction set code, can include industry identifier.
    pub fn transaction_set_identifier(&self) -> std::option::Option<&str> {
        self.transaction_set_identifier.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn guide_id(&self) -> std::option::Option<&str> {
        self.guide_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enable_fragments(&self) -> std::option::Option<bool> {
        self.enable_fragments
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn fragment_size(&self) -> std::option::Option<i32> {
        self.fragment_size
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_x12_transaction_settings_id(&self) -> std::option::Option<&str> {
        self.inbound_x12_transaction_settings_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetInboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
}
impl GetInboundX12TransactionSettingsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_x12_transaction_settings_id(&self) -> std::option::Option<&str> {
        self.inbound_x12_transaction_settings_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetConnectionsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl GetConnectionsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateBucketConnectionInput {
    /// The name of the connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub delete_inbound_files_on_receipt: std::option::Option<bool>,
    /// The name of the stedi bucket
    #[doc(hidden)]
    pub bucket_name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub parent_directory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl CreateBucketConnectionInput {
    /// The name of the connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_subdirectory(&self) -> std::option::Option<&str> {
        self.inbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_subdirectory(&self) -> std::option::Option<&str> {
        self.outbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn delete_inbound_files_on_receipt(&self) -> std::option::Option<bool> {
        self.delete_inbound_files_on_receipt
    }
    /// The name of the stedi bucket
    pub fn bucket_name(&self) -> std::option::Option<&str> {
        self.bucket_name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn parent_directory(&self) -> std::option::Option<&str> {
        self.parent_directory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteBucketConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl DeleteBucketConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateBucketConnectionInput {
    /// The name of the connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_subdirectory: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub delete_inbound_files_on_receipt: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl UpdateBucketConnectionInput {
    /// The name of the connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_subdirectory(&self) -> std::option::Option<&str> {
        self.inbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_subdirectory(&self) -> std::option::Option<&str> {
        self.outbound_subdirectory.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn delete_inbound_files_on_receipt(&self) -> std::option::Option<bool> {
        self.delete_inbound_files_on_receipt
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetBucketConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl GetBucketConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateAs2CredentialsInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_signing: std::option::Option<crate::model::As2LocalCertificate>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_encryption: std::option::Option<crate::model::As2LocalCertificate>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_signing: std::option::Option<crate::model::As2PartnerCertificate>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_encryption: std::option::Option<crate::model::As2PartnerCertificate>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl UpdateAs2CredentialsInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_signing(&self) -> std::option::Option<&crate::model::As2LocalCertificate> {
        self.local_signing.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_encryption(&self) -> std::option::Option<&crate::model::As2LocalCertificate> {
        self.local_encryption.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_signing(&self) -> std::option::Option<&crate::model::As2PartnerCertificate> {
        self.partner_signing.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_encryption(&self) -> std::option::Option<&crate::model::As2PartnerCertificate> {
        self.partner_encryption.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateAs2BasicAuthInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub username: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub password: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl UpdateAs2BasicAuthInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn username(&self) -> std::option::Option<&str> {
        self.username.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn password(&self) -> std::option::Option<&str> {
        self.password.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteAs2BasicAuthInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl DeleteAs2BasicAuthInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateAs2ConnectionInput {
    /// The name of the connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_as2_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_as2_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_settings: std::option::Option<crate::model::As2InboundFields>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_settings: std::option::Option<crate::model::As2OutboundFields>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_signing: std::option::Option<crate::model::As2LocalCertificate>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_encryption: std::option::Option<crate::model::As2LocalCertificate>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_signing: std::option::Option<crate::model::As2PartnerCertificate>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_encryption: std::option::Option<crate::model::As2PartnerCertificate>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl CreateAs2ConnectionInput {
    /// The name of the connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_as2_id(&self) -> std::option::Option<&str> {
        self.local_as2_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_as2_id(&self) -> std::option::Option<&str> {
        self.partner_as2_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_settings(&self) -> std::option::Option<&crate::model::As2InboundFields> {
        self.inbound_settings.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_settings(&self) -> std::option::Option<&crate::model::As2OutboundFields> {
        self.outbound_settings.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_signing(&self) -> std::option::Option<&crate::model::As2LocalCertificate> {
        self.local_signing.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_encryption(&self) -> std::option::Option<&crate::model::As2LocalCertificate> {
        self.local_encryption.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_signing(&self) -> std::option::Option<&crate::model::As2PartnerCertificate> {
        self.partner_signing.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_encryption(&self) -> std::option::Option<&crate::model::As2PartnerCertificate> {
        self.partner_encryption.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteAs2ConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl DeleteAs2ConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateAs2ConnectionInput {
    /// The name of the connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_as2_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_as2_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_settings: std::option::Option<crate::model::As2InboundFields>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub outbound_settings: std::option::Option<crate::model::As2OutboundFields>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl UpdateAs2ConnectionInput {
    /// The name of the connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_as2_id(&self) -> std::option::Option<&str> {
        self.local_as2_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_as2_id(&self) -> std::option::Option<&str> {
        self.partner_as2_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn inbound_settings(&self) -> std::option::Option<&crate::model::As2InboundFields> {
        self.inbound_settings.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn outbound_settings(&self) -> std::option::Option<&crate::model::As2OutboundFields> {
        self.outbound_settings.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetAs2ConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl GetAs2ConnectionInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListGlobalConnectionsInput {
    /// The maximum number of elements to return in a page
    #[doc(hidden)]
    pub page_size: std::option::Option<i32>,
    /// The token used for pagination
    #[doc(hidden)]
    pub page_token: std::option::Option<std::string::String>,
}
impl ListGlobalConnectionsInput {
    /// The maximum number of elements to return in a page
    pub fn page_size(&self) -> std::option::Option<i32> {
        self.page_size
    }
    /// The token used for pagination
    pub fn page_token(&self) -> std::option::Option<&str> {
        self.page_token.as_deref()
    }
}

/// The set of fields that are editable by the user for a global connection
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateGlobalConnectionInput {
    /// The name of the global connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// The name of the stedi bucket
    #[doc(hidden)]
    pub bucket_name: std::option::Option<std::string::String>,
}
impl CreateGlobalConnectionInput {
    /// The name of the global connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// The name of the stedi bucket
    pub fn bucket_name(&self) -> std::option::Option<&str> {
        self.bucket_name.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteGlobalConnectionInput {
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl DeleteGlobalConnectionInput {
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

/// The set of fields that are editable by the user for a global connection
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateGlobalConnectionInput {
    /// The name of the global connection
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl UpdateGlobalConnectionInput {
    /// The name of the global connection
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetGlobalConnectionInput {
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
}
impl GetGlobalConnectionInput {
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct IncrementX12ControlNumberInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub control_number_type: std::option::Option<crate::model::X12ControlNumberType>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl IncrementX12ControlNumberInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn control_number_type(&self) -> std::option::Option<&crate::model::X12ControlNumberType> {
        self.control_number_type.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetX12ProfileByInterchangeInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub interchange_identifier: std::option::Option<crate::model::X12InterchangeIdentifier>,
}
impl GetX12ProfileByInterchangeInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn interchange_identifier(
        &self,
    ) -> std::option::Option<&crate::model::X12InterchangeIdentifier> {
        self.interchange_identifier.as_ref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetX12PartnershipByInterchangesInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_interchange_identifier: std::option::Option<crate::model::X12InterchangeIdentifier>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_interchange_identifier: std::option::Option<crate::model::X12InterchangeIdentifier>,
}
impl GetX12PartnershipByInterchangesInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_interchange_identifier(
        &self,
    ) -> std::option::Option<&crate::model::X12InterchangeIdentifier> {
        self.local_interchange_identifier.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_interchange_identifier(
        &self,
    ) -> std::option::Option<&crate::model::X12InterchangeIdentifier> {
        self.partner_interchange_identifier.as_ref()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GenerateEdiInput {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub transaction_groups: std::option::Option<std::vec::Vec<crate::model::TransactionGroup>>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub interchange_usage_indicator_override: std::option::Option<crate::model::X12UsageIndicator>,
    /// Filename used to save the generated artifact
    #[doc(hidden)]
    pub filename: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub interchange_authorization: std::option::Option<crate::model::X12InterchangeAuthorization>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partnership_id: std::option::Option<std::string::String>,
}
impl GenerateEdiInput {
    #[allow(missing_docs)] // documentation missing in model
    pub fn transaction_groups(&self) -> std::option::Option<&[crate::model::TransactionGroup]> {
        self.transaction_groups.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn interchange_usage_indicator_override(
        &self,
    ) -> std::option::Option<&crate::model::X12UsageIndicator> {
        self.interchange_usage_indicator_override.as_ref()
    }
    /// Filename used to save the generated artifact
    pub fn filename(&self) -> std::option::Option<&str> {
        self.filename.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn interchange_authorization(
        &self,
    ) -> std::option::Option<&crate::model::X12InterchangeAuthorization> {
        self.interchange_authorization.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partnership_id(&self) -> std::option::Option<&str> {
        self.partnership_id.as_deref()
    }
}
