// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Operation shape for `CreateAs2Connection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_as2_connection`](crate::client::Client::create_as2_connection).
///
/// See [`crate::client::fluent_builders::CreateAs2Connection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateAs2Connection {
    _private: (),
}
impl CreateAs2Connection {
    /// 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()
    }
    /// Creates a new `CreateAs2Connection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateAs2Connection {
    type Output = std::result::Result<
        crate::output::CreateAs2ConnectionOutput,
        crate::error::CreateAs2ConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_as2_connection_error(response)
        } else {
            crate::operation_deser::parse_create_as2_connection_response(response)
        }
    }
}

/// Operation shape for `CreateBucketConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_bucket_connection`](crate::client::Client::create_bucket_connection).
///
/// See [`crate::client::fluent_builders::CreateBucketConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateBucketConnection {
    _private: (),
}
impl CreateBucketConnection {
    /// 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()
    }
    /// Creates a new `CreateBucketConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateBucketConnection {
    type Output = std::result::Result<
        crate::output::CreateBucketConnectionOutput,
        crate::error::CreateBucketConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_bucket_connection_error(response)
        } else {
            crate::operation_deser::parse_create_bucket_connection_response(response)
        }
    }
}

/// Operation shape for `CreateGlobalConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_global_connection`](crate::client::Client::create_global_connection).
///
/// See [`crate::client::fluent_builders::CreateGlobalConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateGlobalConnection {
    _private: (),
}
impl CreateGlobalConnection {
    /// 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()
    }
    /// Creates a new `CreateGlobalConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateGlobalConnection {
    type Output = std::result::Result<
        crate::output::CreateGlobalConnectionOutput,
        crate::error::CreateGlobalConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_global_connection_error(response)
        } else {
            crate::operation_deser::parse_create_global_connection_response(response)
        }
    }
}

/// Operation shape for `CreateInboundX12TransactionSettings`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_inbound_x12_transaction_settings`](crate::client::Client::create_inbound_x12_transaction_settings).
///
/// See [`crate::client::fluent_builders::CreateInboundX12TransactionSettings`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateInboundX12TransactionSettings {
    _private: (),
}
impl CreateInboundX12TransactionSettings {
    /// 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()
    }
    /// Creates a new `CreateInboundX12TransactionSettings` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateInboundX12TransactionSettings {
    type Output = std::result::Result<
        crate::output::CreateInboundX12TransactionSettingsOutput,
        crate::error::CreateInboundX12TransactionSettingsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_inbound_x12_transaction_settings_error(response)
        } else {
            crate::operation_deser::parse_create_inbound_x12_transaction_settings_response(response)
        }
    }
}

/// Operation shape for `CreateOutboundX12TransactionSettings`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_outbound_x12_transaction_settings`](crate::client::Client::create_outbound_x12_transaction_settings).
///
/// See [`crate::client::fluent_builders::CreateOutboundX12TransactionSettings`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateOutboundX12TransactionSettings {
    _private: (),
}
impl CreateOutboundX12TransactionSettings {
    /// 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()
    }
    /// Creates a new `CreateOutboundX12TransactionSettings` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateOutboundX12TransactionSettings {
    type Output = std::result::Result<
        crate::output::CreateOutboundX12TransactionSettingsOutput,
        crate::error::CreateOutboundX12TransactionSettingsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_outbound_x12_transaction_settings_error(response)
        } else {
            crate::operation_deser::parse_create_outbound_x12_transaction_settings_response(
                response,
            )
        }
    }
}

/// Operation shape for `CreateRemoteFtpConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_remote_ftp_connection`](crate::client::Client::create_remote_ftp_connection).
///
/// See [`crate::client::fluent_builders::CreateRemoteFtpConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateRemoteFtpConnection {
    _private: (),
}
impl CreateRemoteFtpConnection {
    /// 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()
    }
    /// Creates a new `CreateRemoteFtpConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateRemoteFtpConnection {
    type Output = std::result::Result<
        crate::output::CreateRemoteFtpConnectionOutput,
        crate::error::CreateRemoteFtpConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_remote_ftp_connection_error(response)
        } else {
            crate::operation_deser::parse_create_remote_ftp_connection_response(response)
        }
    }
}

/// Operation shape for `CreateStediFtpConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_stedi_ftp_connection`](crate::client::Client::create_stedi_ftp_connection).
///
/// See [`crate::client::fluent_builders::CreateStediFtpConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateStediFtpConnection {
    _private: (),
}
impl CreateStediFtpConnection {
    /// 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()
    }
    /// Creates a new `CreateStediFtpConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateStediFtpConnection {
    type Output = std::result::Result<
        crate::output::CreateStediFtpConnectionOutput,
        crate::error::CreateStediFtpConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_stedi_ftp_connection_error(response)
        } else {
            crate::operation_deser::parse_create_stedi_ftp_connection_response(response)
        }
    }
}

/// Operation shape for `CreateX12Partnership`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_x12_partnership`](crate::client::Client::create_x12_partnership).
///
/// See [`crate::client::fluent_builders::CreateX12Partnership`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateX12Partnership {
    _private: (),
}
impl CreateX12Partnership {
    /// 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()
    }
    /// Creates a new `CreateX12Partnership` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateX12Partnership {
    type Output = std::result::Result<
        crate::output::CreateX12PartnershipOutput,
        crate::error::CreateX12PartnershipError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_x12_partnership_error(response)
        } else {
            crate::operation_deser::parse_create_x12_partnership_response(response)
        }
    }
}

/// Operation shape for `CreateX12Profile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_x12_profile`](crate::client::Client::create_x12_profile).
///
/// See [`crate::client::fluent_builders::CreateX12Profile`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateX12Profile {
    _private: (),
}
impl CreateX12Profile {
    /// 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()
    }
    /// Creates a new `CreateX12Profile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateX12Profile {
    type Output = std::result::Result<
        crate::output::CreateX12ProfileOutput,
        crate::error::CreateX12ProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_create_x12_profile_error(response)
        } else {
            crate::operation_deser::parse_create_x12_profile_response(response)
        }
    }
}

/// Operation shape for `DeleteAs2BasicAuth`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_as2_basic_auth`](crate::client::Client::delete_as2_basic_auth).
///
/// See [`crate::client::fluent_builders::DeleteAs2BasicAuth`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteAs2BasicAuth {
    _private: (),
}
impl DeleteAs2BasicAuth {
    /// 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()
    }
    /// Creates a new `DeleteAs2BasicAuth` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteAs2BasicAuth {
    type Output = std::result::Result<
        crate::output::DeleteAs2BasicAuthOutput,
        crate::error::DeleteAs2BasicAuthError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_as2_basic_auth_error(response)
        } else {
            crate::operation_deser::parse_delete_as2_basic_auth_response(response)
        }
    }
}

/// Operation shape for `DeleteAs2Connection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_as2_connection`](crate::client::Client::delete_as2_connection).
///
/// See [`crate::client::fluent_builders::DeleteAs2Connection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteAs2Connection {
    _private: (),
}
impl DeleteAs2Connection {
    /// 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()
    }
    /// Creates a new `DeleteAs2Connection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteAs2Connection {
    type Output = std::result::Result<
        crate::output::DeleteAs2ConnectionOutput,
        crate::error::DeleteAs2ConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_as2_connection_error(response)
        } else {
            crate::operation_deser::parse_delete_as2_connection_response(response)
        }
    }
}

/// Operation shape for `DeleteBucketConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_bucket_connection`](crate::client::Client::delete_bucket_connection).
///
/// See [`crate::client::fluent_builders::DeleteBucketConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteBucketConnection {
    _private: (),
}
impl DeleteBucketConnection {
    /// 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()
    }
    /// Creates a new `DeleteBucketConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteBucketConnection {
    type Output = std::result::Result<
        crate::output::DeleteBucketConnectionOutput,
        crate::error::DeleteBucketConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_bucket_connection_error(response)
        } else {
            crate::operation_deser::parse_delete_bucket_connection_response(response)
        }
    }
}

/// Operation shape for `DeleteGlobalConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_global_connection`](crate::client::Client::delete_global_connection).
///
/// See [`crate::client::fluent_builders::DeleteGlobalConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteGlobalConnection {
    _private: (),
}
impl DeleteGlobalConnection {
    /// 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()
    }
    /// Creates a new `DeleteGlobalConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteGlobalConnection {
    type Output = std::result::Result<
        crate::output::DeleteGlobalConnectionOutput,
        crate::error::DeleteGlobalConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_global_connection_error(response)
        } else {
            crate::operation_deser::parse_delete_global_connection_response(response)
        }
    }
}

/// Operation shape for `DeleteInboundX12TransactionSettings`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_inbound_x12_transaction_settings`](crate::client::Client::delete_inbound_x12_transaction_settings).
///
/// See [`crate::client::fluent_builders::DeleteInboundX12TransactionSettings`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteInboundX12TransactionSettings {
    _private: (),
}
impl DeleteInboundX12TransactionSettings {
    /// 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()
    }
    /// Creates a new `DeleteInboundX12TransactionSettings` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteInboundX12TransactionSettings {
    type Output = std::result::Result<
        crate::output::DeleteInboundX12TransactionSettingsOutput,
        crate::error::DeleteInboundX12TransactionSettingsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_inbound_x12_transaction_settings_error(response)
        } else {
            crate::operation_deser::parse_delete_inbound_x12_transaction_settings_response(response)
        }
    }
}

/// Operation shape for `DeleteOutboundX12TransactionSettings`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_outbound_x12_transaction_settings`](crate::client::Client::delete_outbound_x12_transaction_settings).
///
/// See [`crate::client::fluent_builders::DeleteOutboundX12TransactionSettings`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteOutboundX12TransactionSettings {
    _private: (),
}
impl DeleteOutboundX12TransactionSettings {
    /// 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()
    }
    /// Creates a new `DeleteOutboundX12TransactionSettings` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteOutboundX12TransactionSettings {
    type Output = std::result::Result<
        crate::output::DeleteOutboundX12TransactionSettingsOutput,
        crate::error::DeleteOutboundX12TransactionSettingsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_outbound_x12_transaction_settings_error(response)
        } else {
            crate::operation_deser::parse_delete_outbound_x12_transaction_settings_response(
                response,
            )
        }
    }
}

/// Operation shape for `DeleteRemoteFtpConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_remote_ftp_connection`](crate::client::Client::delete_remote_ftp_connection).
///
/// See [`crate::client::fluent_builders::DeleteRemoteFtpConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteRemoteFtpConnection {
    _private: (),
}
impl DeleteRemoteFtpConnection {
    /// 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()
    }
    /// Creates a new `DeleteRemoteFtpConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteRemoteFtpConnection {
    type Output = std::result::Result<
        crate::output::DeleteRemoteFtpConnectionOutput,
        crate::error::DeleteRemoteFtpConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_remote_ftp_connection_error(response)
        } else {
            crate::operation_deser::parse_delete_remote_ftp_connection_response(response)
        }
    }
}

/// Operation shape for `DeleteStediFtpConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_stedi_ftp_connection`](crate::client::Client::delete_stedi_ftp_connection).
///
/// See [`crate::client::fluent_builders::DeleteStediFtpConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteStediFtpConnection {
    _private: (),
}
impl DeleteStediFtpConnection {
    /// 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()
    }
    /// Creates a new `DeleteStediFtpConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteStediFtpConnection {
    type Output = std::result::Result<
        crate::output::DeleteStediFtpConnectionOutput,
        crate::error::DeleteStediFtpConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_stedi_ftp_connection_error(response)
        } else {
            crate::operation_deser::parse_delete_stedi_ftp_connection_response(response)
        }
    }
}

/// Operation shape for `DeleteX12Partnership`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_x12_partnership`](crate::client::Client::delete_x12_partnership).
///
/// See [`crate::client::fluent_builders::DeleteX12Partnership`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteX12Partnership {
    _private: (),
}
impl DeleteX12Partnership {
    /// 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()
    }
    /// Creates a new `DeleteX12Partnership` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteX12Partnership {
    type Output = std::result::Result<
        crate::output::DeleteX12PartnershipOutput,
        crate::error::DeleteX12PartnershipError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_x12_partnership_error(response)
        } else {
            crate::operation_deser::parse_delete_x12_partnership_response(response)
        }
    }
}

/// Operation shape for `DeleteX12Profile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_x12_profile`](crate::client::Client::delete_x12_profile).
///
/// See [`crate::client::fluent_builders::DeleteX12Profile`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteX12Profile {
    _private: (),
}
impl DeleteX12Profile {
    /// 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()
    }
    /// Creates a new `DeleteX12Profile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteX12Profile {
    type Output = std::result::Result<
        crate::output::DeleteX12ProfileOutput,
        crate::error::DeleteX12ProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_x12_profile_error(response)
        } else {
            crate::operation_deser::parse_delete_x12_profile_response(response)
        }
    }
}

/// Operation shape for `GenerateEdi`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`generate_edi`](crate::client::Client::generate_edi).
///
/// See [`crate::client::fluent_builders::GenerateEdi`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GenerateEdi {
    _private: (),
}
impl GenerateEdi {
    /// 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()
    }
    /// Creates a new `GenerateEdi` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GenerateEdi {
    type Output =
        std::result::Result<crate::output::GenerateEdiOutput, crate::error::GenerateEdiError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_generate_edi_error(response)
        } else {
            crate::operation_deser::parse_generate_edi_response(response)
        }
    }
}

/// Operation shape for `GetAs2Connection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_as2_connection`](crate::client::Client::get_as2_connection).
///
/// See [`crate::client::fluent_builders::GetAs2Connection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetAs2Connection {
    _private: (),
}
impl GetAs2Connection {
    /// 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()
    }
    /// Creates a new `GetAs2Connection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetAs2Connection {
    type Output = std::result::Result<
        crate::output::GetAs2ConnectionOutput,
        crate::error::GetAs2ConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_as2_connection_error(response)
        } else {
            crate::operation_deser::parse_get_as2_connection_response(response)
        }
    }
}

/// Operation shape for `GetBucketConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_bucket_connection`](crate::client::Client::get_bucket_connection).
///
/// See [`crate::client::fluent_builders::GetBucketConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetBucketConnection {
    _private: (),
}
impl GetBucketConnection {
    /// 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()
    }
    /// Creates a new `GetBucketConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetBucketConnection {
    type Output = std::result::Result<
        crate::output::GetBucketConnectionOutput,
        crate::error::GetBucketConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_bucket_connection_error(response)
        } else {
            crate::operation_deser::parse_get_bucket_connection_response(response)
        }
    }
}

/// Operation shape for `GetConnections`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_connections`](crate::client::Client::get_connections).
///
/// See [`crate::client::fluent_builders::GetConnections`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetConnections {
    _private: (),
}
impl GetConnections {
    /// 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()
    }
    /// Creates a new `GetConnections` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetConnections {
    type Output =
        std::result::Result<crate::output::GetConnectionsOutput, crate::error::GetConnectionsError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_connections_error(response)
        } else {
            crate::operation_deser::parse_get_connections_response(response)
        }
    }
}

/// Operation shape for `GetGlobalConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_global_connection`](crate::client::Client::get_global_connection).
///
/// See [`crate::client::fluent_builders::GetGlobalConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetGlobalConnection {
    _private: (),
}
impl GetGlobalConnection {
    /// 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()
    }
    /// Creates a new `GetGlobalConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetGlobalConnection {
    type Output = std::result::Result<
        crate::output::GetGlobalConnectionOutput,
        crate::error::GetGlobalConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_global_connection_error(response)
        } else {
            crate::operation_deser::parse_get_global_connection_response(response)
        }
    }
}

/// Operation shape for `GetInboundX12TransactionSettings`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_inbound_x12_transaction_settings`](crate::client::Client::get_inbound_x12_transaction_settings).
///
/// See [`crate::client::fluent_builders::GetInboundX12TransactionSettings`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetInboundX12TransactionSettings {
    _private: (),
}
impl GetInboundX12TransactionSettings {
    /// 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()
    }
    /// Creates a new `GetInboundX12TransactionSettings` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetInboundX12TransactionSettings {
    type Output = std::result::Result<
        crate::output::GetInboundX12TransactionSettingsOutput,
        crate::error::GetInboundX12TransactionSettingsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_inbound_x12_transaction_settings_error(response)
        } else {
            crate::operation_deser::parse_get_inbound_x12_transaction_settings_response(response)
        }
    }
}

/// Operation shape for `GetOutboundX12ControlNumbers`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_outbound_x12_control_numbers`](crate::client::Client::get_outbound_x12_control_numbers).
///
/// See [`crate::client::fluent_builders::GetOutboundX12ControlNumbers`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetOutboundX12ControlNumbers {
    _private: (),
}
impl GetOutboundX12ControlNumbers {
    /// 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()
    }
    /// Creates a new `GetOutboundX12ControlNumbers` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetOutboundX12ControlNumbers {
    type Output = std::result::Result<
        crate::output::GetOutboundX12ControlNumbersOutput,
        crate::error::GetOutboundX12ControlNumbersError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_outbound_x12_control_numbers_error(response)
        } else {
            crate::operation_deser::parse_get_outbound_x12_control_numbers_response(response)
        }
    }
}

/// Operation shape for `GetOutboundX12TransactionSettings`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_outbound_x12_transaction_settings`](crate::client::Client::get_outbound_x12_transaction_settings).
///
/// See [`crate::client::fluent_builders::GetOutboundX12TransactionSettings`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetOutboundX12TransactionSettings {
    _private: (),
}
impl GetOutboundX12TransactionSettings {
    /// 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()
    }
    /// Creates a new `GetOutboundX12TransactionSettings` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetOutboundX12TransactionSettings {
    type Output = std::result::Result<
        crate::output::GetOutboundX12TransactionSettingsOutput,
        crate::error::GetOutboundX12TransactionSettingsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_outbound_x12_transaction_settings_error(response)
        } else {
            crate::operation_deser::parse_get_outbound_x12_transaction_settings_response(response)
        }
    }
}

/// Operation shape for `GetRemoteFtpConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_remote_ftp_connection`](crate::client::Client::get_remote_ftp_connection).
///
/// See [`crate::client::fluent_builders::GetRemoteFtpConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetRemoteFtpConnection {
    _private: (),
}
impl GetRemoteFtpConnection {
    /// 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()
    }
    /// Creates a new `GetRemoteFtpConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetRemoteFtpConnection {
    type Output = std::result::Result<
        crate::output::GetRemoteFtpConnectionOutput,
        crate::error::GetRemoteFtpConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_remote_ftp_connection_error(response)
        } else {
            crate::operation_deser::parse_get_remote_ftp_connection_response(response)
        }
    }
}

/// Operation shape for `GetStediFtpConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_stedi_ftp_connection`](crate::client::Client::get_stedi_ftp_connection).
///
/// See [`crate::client::fluent_builders::GetStediFtpConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetStediFtpConnection {
    _private: (),
}
impl GetStediFtpConnection {
    /// 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()
    }
    /// Creates a new `GetStediFtpConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetStediFtpConnection {
    type Output = std::result::Result<
        crate::output::GetStediFtpConnectionOutput,
        crate::error::GetStediFtpConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_stedi_ftp_connection_error(response)
        } else {
            crate::operation_deser::parse_get_stedi_ftp_connection_response(response)
        }
    }
}

/// Operation shape for `GetX12Partnership`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_x12_partnership`](crate::client::Client::get_x12_partnership).
///
/// See [`crate::client::fluent_builders::GetX12Partnership`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetX12Partnership {
    _private: (),
}
impl GetX12Partnership {
    /// 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()
    }
    /// Creates a new `GetX12Partnership` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetX12Partnership {
    type Output = std::result::Result<
        crate::output::GetX12PartnershipOutput,
        crate::error::GetX12PartnershipError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_x12_partnership_error(response)
        } else {
            crate::operation_deser::parse_get_x12_partnership_response(response)
        }
    }
}

/// Operation shape for `GetX12PartnershipByInterchanges`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_x12_partnership_by_interchanges`](crate::client::Client::get_x12_partnership_by_interchanges).
///
/// See [`crate::client::fluent_builders::GetX12PartnershipByInterchanges`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetX12PartnershipByInterchanges {
    _private: (),
}
impl GetX12PartnershipByInterchanges {
    /// 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()
    }
    /// Creates a new `GetX12PartnershipByInterchanges` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetX12PartnershipByInterchanges {
    type Output = std::result::Result<
        crate::output::GetX12PartnershipByInterchangesOutput,
        crate::error::GetX12PartnershipByInterchangesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_x12_partnership_by_interchanges_error(response)
        } else {
            crate::operation_deser::parse_get_x12_partnership_by_interchanges_response(response)
        }
    }
}

/// Operation shape for `GetX12Profile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_x12_profile`](crate::client::Client::get_x12_profile).
///
/// See [`crate::client::fluent_builders::GetX12Profile`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetX12Profile {
    _private: (),
}
impl GetX12Profile {
    /// 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()
    }
    /// Creates a new `GetX12Profile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetX12Profile {
    type Output =
        std::result::Result<crate::output::GetX12ProfileOutput, crate::error::GetX12ProfileError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_x12_profile_error(response)
        } else {
            crate::operation_deser::parse_get_x12_profile_response(response)
        }
    }
}

/// Operation shape for `GetX12ProfileByInterchange`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_x12_profile_by_interchange`](crate::client::Client::get_x12_profile_by_interchange).
///
/// See [`crate::client::fluent_builders::GetX12ProfileByInterchange`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetX12ProfileByInterchange {
    _private: (),
}
impl GetX12ProfileByInterchange {
    /// 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()
    }
    /// Creates a new `GetX12ProfileByInterchange` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetX12ProfileByInterchange {
    type Output = std::result::Result<
        crate::output::GetX12ProfileByInterchangeOutput,
        crate::error::GetX12ProfileByInterchangeError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_x12_profile_by_interchange_error(response)
        } else {
            crate::operation_deser::parse_get_x12_profile_by_interchange_response(response)
        }
    }
}

/// Operation shape for `IncrementX12ControlNumber`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`increment_x12_control_number`](crate::client::Client::increment_x12_control_number).
///
/// See [`crate::client::fluent_builders::IncrementX12ControlNumber`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct IncrementX12ControlNumber {
    _private: (),
}
impl IncrementX12ControlNumber {
    /// 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()
    }
    /// Creates a new `IncrementX12ControlNumber` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for IncrementX12ControlNumber {
    type Output = std::result::Result<
        crate::output::IncrementX12ControlNumberOutput,
        crate::error::IncrementX12ControlNumberError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_increment_x12_control_number_error(response)
        } else {
            crate::operation_deser::parse_increment_x12_control_number_response(response)
        }
    }
}

/// Operation shape for `ListGlobalConnections`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_global_connections`](crate::client::Client::list_global_connections).
///
/// See [`crate::client::fluent_builders::ListGlobalConnections`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListGlobalConnections {
    _private: (),
}
impl ListGlobalConnections {
    /// 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()
    }
    /// Creates a new `ListGlobalConnections` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListGlobalConnections {
    type Output = std::result::Result<
        crate::output::ListGlobalConnectionsOutput,
        crate::error::ListGlobalConnectionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_global_connections_error(response)
        } else {
            crate::operation_deser::parse_list_global_connections_response(response)
        }
    }
}

/// Operation shape for `ListX12Partnerships`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_x12_partnerships`](crate::client::Client::list_x12_partnerships).
///
/// See [`crate::client::fluent_builders::ListX12Partnerships`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListX12Partnerships {
    _private: (),
}
impl ListX12Partnerships {
    /// 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()
    }
    /// Creates a new `ListX12Partnerships` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListX12Partnerships {
    type Output = std::result::Result<
        crate::output::ListX12PartnershipsOutput,
        crate::error::ListX12PartnershipsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_x12_partnerships_error(response)
        } else {
            crate::operation_deser::parse_list_x12_partnerships_response(response)
        }
    }
}

/// Operation shape for `ListX12Profiles`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_x12_profiles`](crate::client::Client::list_x12_profiles).
///
/// See [`crate::client::fluent_builders::ListX12Profiles`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListX12Profiles {
    _private: (),
}
impl ListX12Profiles {
    /// 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()
    }
    /// Creates a new `ListX12Profiles` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListX12Profiles {
    type Output = std::result::Result<
        crate::output::ListX12ProfilesOutput,
        crate::error::ListX12ProfilesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_x12_profiles_error(response)
        } else {
            crate::operation_deser::parse_list_x12_profiles_response(response)
        }
    }
}

/// Operation shape for `SetOutboundX12ControlNumber`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`set_outbound_x12_control_number`](crate::client::Client::set_outbound_x12_control_number).
///
/// See [`crate::client::fluent_builders::SetOutboundX12ControlNumber`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct SetOutboundX12ControlNumber {
    _private: (),
}
impl SetOutboundX12ControlNumber {
    /// 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()
    }
    /// Creates a new `SetOutboundX12ControlNumber` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for SetOutboundX12ControlNumber {
    type Output = std::result::Result<
        crate::output::SetOutboundX12ControlNumberOutput,
        crate::error::SetOutboundX12ControlNumberError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_set_outbound_x12_control_number_error(response)
        } else {
            crate::operation_deser::parse_set_outbound_x12_control_number_response(response)
        }
    }
}

/// Operation shape for `UpdateAs2BasicAuth`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_as2_basic_auth`](crate::client::Client::update_as2_basic_auth).
///
/// See [`crate::client::fluent_builders::UpdateAs2BasicAuth`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateAs2BasicAuth {
    _private: (),
}
impl UpdateAs2BasicAuth {
    /// 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()
    }
    /// Creates a new `UpdateAs2BasicAuth` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateAs2BasicAuth {
    type Output = std::result::Result<
        crate::output::UpdateAs2BasicAuthOutput,
        crate::error::UpdateAs2BasicAuthError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_as2_basic_auth_error(response)
        } else {
            crate::operation_deser::parse_update_as2_basic_auth_response(response)
        }
    }
}

/// Operation shape for `UpdateAs2Connection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_as2_connection`](crate::client::Client::update_as2_connection).
///
/// See [`crate::client::fluent_builders::UpdateAs2Connection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateAs2Connection {
    _private: (),
}
impl UpdateAs2Connection {
    /// 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()
    }
    /// Creates a new `UpdateAs2Connection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateAs2Connection {
    type Output = std::result::Result<
        crate::output::UpdateAs2ConnectionOutput,
        crate::error::UpdateAs2ConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_as2_connection_error(response)
        } else {
            crate::operation_deser::parse_update_as2_connection_response(response)
        }
    }
}

/// Operation shape for `UpdateAs2Credentials`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_as2_credentials`](crate::client::Client::update_as2_credentials).
///
/// See [`crate::client::fluent_builders::UpdateAs2Credentials`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateAs2Credentials {
    _private: (),
}
impl UpdateAs2Credentials {
    /// 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()
    }
    /// Creates a new `UpdateAs2Credentials` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateAs2Credentials {
    type Output = std::result::Result<
        crate::output::UpdateAs2CredentialsOutput,
        crate::error::UpdateAs2CredentialsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_as2_credentials_error(response)
        } else {
            crate::operation_deser::parse_update_as2_credentials_response(response)
        }
    }
}

/// Operation shape for `UpdateBucketConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_bucket_connection`](crate::client::Client::update_bucket_connection).
///
/// See [`crate::client::fluent_builders::UpdateBucketConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateBucketConnection {
    _private: (),
}
impl UpdateBucketConnection {
    /// 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()
    }
    /// Creates a new `UpdateBucketConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateBucketConnection {
    type Output = std::result::Result<
        crate::output::UpdateBucketConnectionOutput,
        crate::error::UpdateBucketConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_bucket_connection_error(response)
        } else {
            crate::operation_deser::parse_update_bucket_connection_response(response)
        }
    }
}

/// Operation shape for `UpdateGlobalConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_global_connection`](crate::client::Client::update_global_connection).
///
/// See [`crate::client::fluent_builders::UpdateGlobalConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateGlobalConnection {
    _private: (),
}
impl UpdateGlobalConnection {
    /// 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()
    }
    /// Creates a new `UpdateGlobalConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateGlobalConnection {
    type Output = std::result::Result<
        crate::output::UpdateGlobalConnectionOutput,
        crate::error::UpdateGlobalConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_global_connection_error(response)
        } else {
            crate::operation_deser::parse_update_global_connection_response(response)
        }
    }
}

/// Operation shape for `UpdateInboundX12TransactionSettings`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_inbound_x12_transaction_settings`](crate::client::Client::update_inbound_x12_transaction_settings).
///
/// See [`crate::client::fluent_builders::UpdateInboundX12TransactionSettings`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateInboundX12TransactionSettings {
    _private: (),
}
impl UpdateInboundX12TransactionSettings {
    /// 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()
    }
    /// Creates a new `UpdateInboundX12TransactionSettings` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateInboundX12TransactionSettings {
    type Output = std::result::Result<
        crate::output::UpdateInboundX12TransactionSettingsOutput,
        crate::error::UpdateInboundX12TransactionSettingsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_inbound_x12_transaction_settings_error(response)
        } else {
            crate::operation_deser::parse_update_inbound_x12_transaction_settings_response(response)
        }
    }
}

/// Operation shape for `UpdateOutboundX12TransactionSettings`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_outbound_x12_transaction_settings`](crate::client::Client::update_outbound_x12_transaction_settings).
///
/// See [`crate::client::fluent_builders::UpdateOutboundX12TransactionSettings`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateOutboundX12TransactionSettings {
    _private: (),
}
impl UpdateOutboundX12TransactionSettings {
    /// 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()
    }
    /// Creates a new `UpdateOutboundX12TransactionSettings` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateOutboundX12TransactionSettings {
    type Output = std::result::Result<
        crate::output::UpdateOutboundX12TransactionSettingsOutput,
        crate::error::UpdateOutboundX12TransactionSettingsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_outbound_x12_transaction_settings_error(response)
        } else {
            crate::operation_deser::parse_update_outbound_x12_transaction_settings_response(
                response,
            )
        }
    }
}

/// Operation shape for `UpdateRemoteFtpConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_remote_ftp_connection`](crate::client::Client::update_remote_ftp_connection).
///
/// See [`crate::client::fluent_builders::UpdateRemoteFtpConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateRemoteFtpConnection {
    _private: (),
}
impl UpdateRemoteFtpConnection {
    /// 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()
    }
    /// Creates a new `UpdateRemoteFtpConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateRemoteFtpConnection {
    type Output = std::result::Result<
        crate::output::UpdateRemoteFtpConnectionOutput,
        crate::error::UpdateRemoteFtpConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_remote_ftp_connection_error(response)
        } else {
            crate::operation_deser::parse_update_remote_ftp_connection_response(response)
        }
    }
}

/// Operation shape for `UpdateRemoteFtpCredentials`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_remote_ftp_credentials`](crate::client::Client::update_remote_ftp_credentials).
///
/// See [`crate::client::fluent_builders::UpdateRemoteFtpCredentials`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateRemoteFtpCredentials {
    _private: (),
}
impl UpdateRemoteFtpCredentials {
    /// 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()
    }
    /// Creates a new `UpdateRemoteFtpCredentials` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateRemoteFtpCredentials {
    type Output = std::result::Result<
        crate::output::UpdateRemoteFtpCredentialsOutput,
        crate::error::UpdateRemoteFtpCredentialsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_remote_ftp_credentials_error(response)
        } else {
            crate::operation_deser::parse_update_remote_ftp_credentials_response(response)
        }
    }
}

/// Operation shape for `UpdateStediFtpConnection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_stedi_ftp_connection`](crate::client::Client::update_stedi_ftp_connection).
///
/// See [`crate::client::fluent_builders::UpdateStediFtpConnection`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateStediFtpConnection {
    _private: (),
}
impl UpdateStediFtpConnection {
    /// 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()
    }
    /// Creates a new `UpdateStediFtpConnection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateStediFtpConnection {
    type Output = std::result::Result<
        crate::output::UpdateStediFtpConnectionOutput,
        crate::error::UpdateStediFtpConnectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_stedi_ftp_connection_error(response)
        } else {
            crate::operation_deser::parse_update_stedi_ftp_connection_response(response)
        }
    }
}

/// Operation shape for `UpdateX12Partnership`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_x12_partnership`](crate::client::Client::update_x12_partnership).
///
/// See [`crate::client::fluent_builders::UpdateX12Partnership`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateX12Partnership {
    _private: (),
}
impl UpdateX12Partnership {
    /// 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()
    }
    /// Creates a new `UpdateX12Partnership` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateX12Partnership {
    type Output = std::result::Result<
        crate::output::UpdateX12PartnershipOutput,
        crate::error::UpdateX12PartnershipError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 201 {
            crate::operation_deser::parse_update_x12_partnership_error(response)
        } else {
            crate::operation_deser::parse_update_x12_partnership_response(response)
        }
    }
}

/// Operation shape for `UpdateX12Profile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_x12_profile`](crate::client::Client::update_x12_profile).
///
/// See [`crate::client::fluent_builders::UpdateX12Profile`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateX12Profile {
    _private: (),
}
impl UpdateX12Profile {
    /// 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()
    }
    /// Creates a new `UpdateX12Profile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateX12Profile {
    type Output = std::result::Result<
        crate::output::UpdateX12ProfileOutput,
        crate::error::UpdateX12ProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_x12_profile_error(response)
        } else {
            crate::operation_deser::parse_update_x12_profile_response(response)
        }
    }
}

/// Operation customization and supporting types
pub mod customize;
