// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct X12ProfileSummary {
    #[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>>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
}
impl X12ProfileSummary {
    #[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
    pub fn created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.as_ref()
    }
}
/// See [`X12ProfileSummary`](crate::model::X12ProfileSummary).
pub mod x12_profile_summary {

    /// A builder for [`X12ProfileSummary`](crate::model::X12ProfileSummary).
    #[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>>,
        pub(crate) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = input;
            self
        }
        /// Consumes the builder and constructs a [`X12ProfileSummary`](crate::model::X12ProfileSummary).
        pub fn build(self) -> crate::model::X12ProfileSummary {
            crate::model::X12ProfileSummary {
                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,
                created_at: self.created_at,
                updated_at: self.updated_at,
            }
        }
    }
}
impl X12ProfileSummary {
    /// Creates a new builder-style object to manufacture [`X12ProfileSummary`](crate::model::X12ProfileSummary).
    pub fn builder() -> crate::model::x12_profile_summary::Builder {
        crate::model::x12_profile_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct X12ApplicationId {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub value: std::option::Option<std::string::String>,
    /// The default value used for the outbound transaction settings that do not have a value. Changing the default will update the runtime behavior of the generate-edi operation for the transaction settings that did not specify a value.
    #[doc(hidden)]
    pub is_default: std::option::Option<bool>,
}
impl X12ApplicationId {
    #[allow(missing_docs)] // documentation missing in model
    pub fn value(&self) -> std::option::Option<&str> {
        self.value.as_deref()
    }
    /// The default value used for the outbound transaction settings that do not have a value. Changing the default will update the runtime behavior of the generate-edi operation for the transaction settings that did not specify a value.
    pub fn is_default(&self) -> std::option::Option<bool> {
        self.is_default
    }
}
/// See [`X12ApplicationId`](crate::model::X12ApplicationId).
pub mod x12_application_id {

    /// A builder for [`X12ApplicationId`](crate::model::X12ApplicationId).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) value: std::option::Option<std::string::String>,
        pub(crate) is_default: std::option::Option<bool>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn value(mut self, input: impl Into<std::string::String>) -> Self {
            self.value = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_value(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.value = input;
            self
        }
        /// The default value used for the outbound transaction settings that do not have a value. Changing the default will update the runtime behavior of the generate-edi operation for the transaction settings that did not specify a value.
        pub fn is_default(mut self, input: bool) -> Self {
            self.is_default = Some(input);
            self
        }
        /// The default value used for the outbound transaction settings that do not have a value. Changing the default will update the runtime behavior of the generate-edi operation for the transaction settings that did not specify a value.
        pub fn set_is_default(mut self, input: std::option::Option<bool>) -> Self {
            self.is_default = input;
            self
        }
        /// Consumes the builder and constructs a [`X12ApplicationId`](crate::model::X12ApplicationId).
        pub fn build(self) -> crate::model::X12ApplicationId {
            crate::model::X12ApplicationId {
                value: self.value,
                is_default: self.is_default,
            }
        }
    }
}
impl X12ApplicationId {
    /// Creates a new builder-style object to manufacture [`X12ApplicationId`](crate::model::X12ApplicationId).
    pub fn builder() -> crate::model::x12_application_id::Builder {
        crate::model::x12_application_id::Builder::default()
    }
}

/// When writing a match expression against `ProfileType`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let profiletype = unimplemented!();
/// match profiletype {
///     ProfileType::Local => { /* ... */ },
///     ProfileType::Partner => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `profiletype` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `ProfileType::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `ProfileType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `ProfileType::NewFeature` is defined.
/// Specifically, when `profiletype` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `ProfileType::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum ProfileType {
    #[allow(missing_docs)] // documentation missing in model
    Local,
    #[allow(missing_docs)] // documentation missing in model
    Partner,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ProfileType {
    fn from(s: &str) -> Self {
        match s {
            "local" => ProfileType::Local,
            "partner" => ProfileType::Partner,
            other => ProfileType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for ProfileType {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(ProfileType::from(s))
    }
}
impl ProfileType {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            ProfileType::Local => "local",
            ProfileType::Partner => "partner",
            ProfileType::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["local", "partner"]
    }
}
impl AsRef<str> for ProfileType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `X12InterchangeQualifier`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let x12interchangequalifier = unimplemented!();
/// match x12interchangequalifier {
///     X12InterchangeQualifier::Code01 => { /* ... */ },
///     X12InterchangeQualifier::Code02 => { /* ... */ },
///     X12InterchangeQualifier::Code03 => { /* ... */ },
///     X12InterchangeQualifier::Code04 => { /* ... */ },
///     X12InterchangeQualifier::Code07 => { /* ... */ },
///     X12InterchangeQualifier::Code08 => { /* ... */ },
///     X12InterchangeQualifier::Code09 => { /* ... */ },
///     X12InterchangeQualifier::Code10 => { /* ... */ },
///     X12InterchangeQualifier::Code11 => { /* ... */ },
///     X12InterchangeQualifier::Code12 => { /* ... */ },
///     X12InterchangeQualifier::Code13 => { /* ... */ },
///     X12InterchangeQualifier::Code14 => { /* ... */ },
///     X12InterchangeQualifier::Code15 => { /* ... */ },
///     X12InterchangeQualifier::Code16 => { /* ... */ },
///     X12InterchangeQualifier::Code17 => { /* ... */ },
///     X12InterchangeQualifier::Code18 => { /* ... */ },
///     X12InterchangeQualifier::Code19 => { /* ... */ },
///     X12InterchangeQualifier::Code20 => { /* ... */ },
///     X12InterchangeQualifier::Code21 => { /* ... */ },
///     X12InterchangeQualifier::Code22 => { /* ... */ },
///     X12InterchangeQualifier::Code23 => { /* ... */ },
///     X12InterchangeQualifier::Code24 => { /* ... */ },
///     X12InterchangeQualifier::Code25 => { /* ... */ },
///     X12InterchangeQualifier::Code26 => { /* ... */ },
///     X12InterchangeQualifier::Code27 => { /* ... */ },
///     X12InterchangeQualifier::Code28 => { /* ... */ },
///     X12InterchangeQualifier::Code29 => { /* ... */ },
///     X12InterchangeQualifier::Code30 => { /* ... */ },
///     X12InterchangeQualifier::Code31 => { /* ... */ },
///     X12InterchangeQualifier::Code32 => { /* ... */ },
///     X12InterchangeQualifier::Code33 => { /* ... */ },
///     X12InterchangeQualifier::Code34 => { /* ... */ },
///     X12InterchangeQualifier::Code35 => { /* ... */ },
///     X12InterchangeQualifier::Code36 => { /* ... */ },
///     X12InterchangeQualifier::Code37 => { /* ... */ },
///     X12InterchangeQualifier::Code38 => { /* ... */ },
///     X12InterchangeQualifier::CodeAm => { /* ... */ },
///     X12InterchangeQualifier::CodeNr => { /* ... */ },
///     X12InterchangeQualifier::CodeSa => { /* ... */ },
///     X12InterchangeQualifier::CodeSn => { /* ... */ },
///     X12InterchangeQualifier::CodeZz => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `x12interchangequalifier` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `X12InterchangeQualifier::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `X12InterchangeQualifier::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `X12InterchangeQualifier::NewFeature` is defined.
/// Specifically, when `x12interchangequalifier` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `X12InterchangeQualifier::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum X12InterchangeQualifier {
    #[allow(missing_docs)] // documentation missing in model
    Code01,
    #[allow(missing_docs)] // documentation missing in model
    Code02,
    #[allow(missing_docs)] // documentation missing in model
    Code03,
    #[allow(missing_docs)] // documentation missing in model
    Code04,
    #[allow(missing_docs)] // documentation missing in model
    Code07,
    #[allow(missing_docs)] // documentation missing in model
    Code08,
    #[allow(missing_docs)] // documentation missing in model
    Code09,
    #[allow(missing_docs)] // documentation missing in model
    Code10,
    #[allow(missing_docs)] // documentation missing in model
    Code11,
    #[allow(missing_docs)] // documentation missing in model
    Code12,
    #[allow(missing_docs)] // documentation missing in model
    Code13,
    #[allow(missing_docs)] // documentation missing in model
    Code14,
    #[allow(missing_docs)] // documentation missing in model
    Code15,
    #[allow(missing_docs)] // documentation missing in model
    Code16,
    #[allow(missing_docs)] // documentation missing in model
    Code17,
    #[allow(missing_docs)] // documentation missing in model
    Code18,
    #[allow(missing_docs)] // documentation missing in model
    Code19,
    #[allow(missing_docs)] // documentation missing in model
    Code20,
    #[allow(missing_docs)] // documentation missing in model
    Code21,
    #[allow(missing_docs)] // documentation missing in model
    Code22,
    #[allow(missing_docs)] // documentation missing in model
    Code23,
    #[allow(missing_docs)] // documentation missing in model
    Code24,
    #[allow(missing_docs)] // documentation missing in model
    Code25,
    #[allow(missing_docs)] // documentation missing in model
    Code26,
    #[allow(missing_docs)] // documentation missing in model
    Code27,
    #[allow(missing_docs)] // documentation missing in model
    Code28,
    #[allow(missing_docs)] // documentation missing in model
    Code29,
    #[allow(missing_docs)] // documentation missing in model
    Code30,
    #[allow(missing_docs)] // documentation missing in model
    Code31,
    #[allow(missing_docs)] // documentation missing in model
    Code32,
    #[allow(missing_docs)] // documentation missing in model
    Code33,
    #[allow(missing_docs)] // documentation missing in model
    Code34,
    #[allow(missing_docs)] // documentation missing in model
    Code35,
    #[allow(missing_docs)] // documentation missing in model
    Code36,
    #[allow(missing_docs)] // documentation missing in model
    Code37,
    #[allow(missing_docs)] // documentation missing in model
    Code38,
    #[allow(missing_docs)] // documentation missing in model
    CodeAm,
    #[allow(missing_docs)] // documentation missing in model
    CodeNr,
    #[allow(missing_docs)] // documentation missing in model
    CodeSa,
    #[allow(missing_docs)] // documentation missing in model
    CodeSn,
    #[allow(missing_docs)] // documentation missing in model
    CodeZz,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for X12InterchangeQualifier {
    fn from(s: &str) -> Self {
        match s {
            "01" => X12InterchangeQualifier::Code01,
            "02" => X12InterchangeQualifier::Code02,
            "03" => X12InterchangeQualifier::Code03,
            "04" => X12InterchangeQualifier::Code04,
            "07" => X12InterchangeQualifier::Code07,
            "08" => X12InterchangeQualifier::Code08,
            "09" => X12InterchangeQualifier::Code09,
            "10" => X12InterchangeQualifier::Code10,
            "11" => X12InterchangeQualifier::Code11,
            "12" => X12InterchangeQualifier::Code12,
            "13" => X12InterchangeQualifier::Code13,
            "14" => X12InterchangeQualifier::Code14,
            "15" => X12InterchangeQualifier::Code15,
            "16" => X12InterchangeQualifier::Code16,
            "17" => X12InterchangeQualifier::Code17,
            "18" => X12InterchangeQualifier::Code18,
            "19" => X12InterchangeQualifier::Code19,
            "20" => X12InterchangeQualifier::Code20,
            "21" => X12InterchangeQualifier::Code21,
            "22" => X12InterchangeQualifier::Code22,
            "23" => X12InterchangeQualifier::Code23,
            "24" => X12InterchangeQualifier::Code24,
            "25" => X12InterchangeQualifier::Code25,
            "26" => X12InterchangeQualifier::Code26,
            "27" => X12InterchangeQualifier::Code27,
            "28" => X12InterchangeQualifier::Code28,
            "29" => X12InterchangeQualifier::Code29,
            "30" => X12InterchangeQualifier::Code30,
            "31" => X12InterchangeQualifier::Code31,
            "32" => X12InterchangeQualifier::Code32,
            "33" => X12InterchangeQualifier::Code33,
            "34" => X12InterchangeQualifier::Code34,
            "35" => X12InterchangeQualifier::Code35,
            "36" => X12InterchangeQualifier::Code36,
            "37" => X12InterchangeQualifier::Code37,
            "38" => X12InterchangeQualifier::Code38,
            "AM" => X12InterchangeQualifier::CodeAm,
            "NR" => X12InterchangeQualifier::CodeNr,
            "SA" => X12InterchangeQualifier::CodeSa,
            "SN" => X12InterchangeQualifier::CodeSn,
            "ZZ" => X12InterchangeQualifier::CodeZz,
            other => X12InterchangeQualifier::Unknown(crate::types::UnknownVariantValue(
                other.to_owned(),
            )),
        }
    }
}
impl std::str::FromStr for X12InterchangeQualifier {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(X12InterchangeQualifier::from(s))
    }
}
impl X12InterchangeQualifier {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            X12InterchangeQualifier::Code01 => "01",
            X12InterchangeQualifier::Code02 => "02",
            X12InterchangeQualifier::Code03 => "03",
            X12InterchangeQualifier::Code04 => "04",
            X12InterchangeQualifier::Code07 => "07",
            X12InterchangeQualifier::Code08 => "08",
            X12InterchangeQualifier::Code09 => "09",
            X12InterchangeQualifier::Code10 => "10",
            X12InterchangeQualifier::Code11 => "11",
            X12InterchangeQualifier::Code12 => "12",
            X12InterchangeQualifier::Code13 => "13",
            X12InterchangeQualifier::Code14 => "14",
            X12InterchangeQualifier::Code15 => "15",
            X12InterchangeQualifier::Code16 => "16",
            X12InterchangeQualifier::Code17 => "17",
            X12InterchangeQualifier::Code18 => "18",
            X12InterchangeQualifier::Code19 => "19",
            X12InterchangeQualifier::Code20 => "20",
            X12InterchangeQualifier::Code21 => "21",
            X12InterchangeQualifier::Code22 => "22",
            X12InterchangeQualifier::Code23 => "23",
            X12InterchangeQualifier::Code24 => "24",
            X12InterchangeQualifier::Code25 => "25",
            X12InterchangeQualifier::Code26 => "26",
            X12InterchangeQualifier::Code27 => "27",
            X12InterchangeQualifier::Code28 => "28",
            X12InterchangeQualifier::Code29 => "29",
            X12InterchangeQualifier::Code30 => "30",
            X12InterchangeQualifier::Code31 => "31",
            X12InterchangeQualifier::Code32 => "32",
            X12InterchangeQualifier::Code33 => "33",
            X12InterchangeQualifier::Code34 => "34",
            X12InterchangeQualifier::Code35 => "35",
            X12InterchangeQualifier::Code36 => "36",
            X12InterchangeQualifier::Code37 => "37",
            X12InterchangeQualifier::Code38 => "38",
            X12InterchangeQualifier::CodeAm => "AM",
            X12InterchangeQualifier::CodeNr => "NR",
            X12InterchangeQualifier::CodeSa => "SA",
            X12InterchangeQualifier::CodeSn => "SN",
            X12InterchangeQualifier::CodeZz => "ZZ",
            X12InterchangeQualifier::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "01", "02", "03", "04", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16",
            "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30",
            "31", "32", "33", "34", "35", "36", "37", "38", "AM", "NR", "SA", "SN", "ZZ",
        ]
    }
}
impl AsRef<str> for X12InterchangeQualifier {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct X12PartnershipSummary {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
    #[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 connection_count: std::option::Option<i32>,
}
impl X12PartnershipSummary {
    #[allow(missing_docs)] // documentation missing in model
    pub fn created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.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 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 connection_count(&self) -> std::option::Option<i32> {
        self.connection_count
    }
}
/// See [`X12PartnershipSummary`](crate::model::X12PartnershipSummary).
pub mod x12_partnership_summary {

    /// A builder for [`X12PartnershipSummary`](crate::model::X12PartnershipSummary).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
        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) connection_count: std::option::Option<i32>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = 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 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 connection_count(mut self, input: i32) -> Self {
            self.connection_count = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_connection_count(mut self, input: std::option::Option<i32>) -> Self {
            self.connection_count = input;
            self
        }
        /// Consumes the builder and constructs a [`X12PartnershipSummary`](crate::model::X12PartnershipSummary).
        pub fn build(self) -> crate::model::X12PartnershipSummary {
            crate::model::X12PartnershipSummary {
                created_at: self.created_at,
                updated_at: self.updated_at,
                partnership_id: self.partnership_id,
                local_profile_id: self.local_profile_id,
                partner_profile_id: self.partner_profile_id,
                connection_count: self.connection_count,
            }
        }
    }
}
impl X12PartnershipSummary {
    /// Creates a new builder-style object to manufacture [`X12PartnershipSummary`](crate::model::X12PartnershipSummary).
    pub fn builder() -> crate::model::x12_partnership_summary::Builder {
        crate::model::x12_partnership_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct X12PartnershipAckConfiguration {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
    /// The transaction set to use when acknowledging a functional group. code | description -----|-------------------------- 997 | Used in all transaction sets. Not used to respond to a 997 999 | Used in some healthcare transaction sets. Not used to respond to a 999.
    #[doc(hidden)]
    pub functional_acknowledgment_type:
        std::option::Option<crate::model::X12FunctionalAcknowledgmentType>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub connection: std::option::Option<crate::model::OutboundConnection>,
}
impl X12PartnershipAckConfiguration {
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
    /// The transaction set to use when acknowledging a functional group. code | description -----|-------------------------- 997 | Used in all transaction sets. Not used to respond to a 997 999 | Used in some healthcare transaction sets. Not used to respond to a 999.
    pub fn functional_acknowledgment_type(
        &self,
    ) -> std::option::Option<&crate::model::X12FunctionalAcknowledgmentType> {
        self.functional_acknowledgment_type.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn connection(&self) -> std::option::Option<&crate::model::OutboundConnection> {
        self.connection.as_ref()
    }
}
/// See [`X12PartnershipAckConfiguration`](crate::model::X12PartnershipAckConfiguration).
pub mod x12_partnership_ack_configuration {

    /// A builder for [`X12PartnershipAckConfiguration`](crate::model::X12PartnershipAckConfiguration).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) enabled: std::option::Option<bool>,
        pub(crate) functional_acknowledgment_type:
            std::option::Option<crate::model::X12FunctionalAcknowledgmentType>,
        pub(crate) connection: std::option::Option<crate::model::OutboundConnection>,
    }
    impl Builder {
        #[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
        }
        /// The transaction set to use when acknowledging a functional group. code | description -----|-------------------------- 997 | Used in all transaction sets. Not used to respond to a 997 999 | Used in some healthcare transaction sets. Not used to respond to a 999.
        pub fn functional_acknowledgment_type(
            mut self,
            input: crate::model::X12FunctionalAcknowledgmentType,
        ) -> Self {
            self.functional_acknowledgment_type = Some(input);
            self
        }
        /// The transaction set to use when acknowledging a functional group. code | description -----|-------------------------- 997 | Used in all transaction sets. Not used to respond to a 997 999 | Used in some healthcare transaction sets. Not used to respond to a 999.
        pub fn set_functional_acknowledgment_type(
            mut self,
            input: std::option::Option<crate::model::X12FunctionalAcknowledgmentType>,
        ) -> Self {
            self.functional_acknowledgment_type = 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
        }
        /// Consumes the builder and constructs a [`X12PartnershipAckConfiguration`](crate::model::X12PartnershipAckConfiguration).
        pub fn build(self) -> crate::model::X12PartnershipAckConfiguration {
            crate::model::X12PartnershipAckConfiguration {
                enabled: self.enabled,
                functional_acknowledgment_type: self.functional_acknowledgment_type,
                connection: self.connection,
            }
        }
    }
}
impl X12PartnershipAckConfiguration {
    /// Creates a new builder-style object to manufacture [`X12PartnershipAckConfiguration`](crate::model::X12PartnershipAckConfiguration).
    pub fn builder() -> crate::model::x12_partnership_ack_configuration::Builder {
        crate::model::x12_partnership_ack_configuration::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct OutboundConnection {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub connection_type: std::option::Option<crate::model::ConnectionType>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    /// Optional subdirectory used to store generated EDI files
    #[doc(hidden)]
    pub subdirectory: std::option::Option<std::string::String>,
}
impl OutboundConnection {
    #[allow(missing_docs)] // documentation missing in model
    pub fn connection_type(&self) -> std::option::Option<&crate::model::ConnectionType> {
        self.connection_type.as_ref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    /// Optional subdirectory used to store generated EDI files
    pub fn subdirectory(&self) -> std::option::Option<&str> {
        self.subdirectory.as_deref()
    }
}
/// See [`OutboundConnection`](crate::model::OutboundConnection).
pub mod outbound_connection {

    /// A builder for [`OutboundConnection`](crate::model::OutboundConnection).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) connection_type: std::option::Option<crate::model::ConnectionType>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) subdirectory: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn connection_type(mut self, input: crate::model::ConnectionType) -> Self {
            self.connection_type = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_connection_type(
            mut self,
            input: std::option::Option<crate::model::ConnectionType>,
        ) -> Self {
            self.connection_type = 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
        }
        /// Optional subdirectory used to store generated EDI files
        pub fn subdirectory(mut self, input: impl Into<std::string::String>) -> Self {
            self.subdirectory = Some(input.into());
            self
        }
        /// Optional subdirectory used to store generated EDI files
        pub fn set_subdirectory(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.subdirectory = input;
            self
        }
        /// Consumes the builder and constructs a [`OutboundConnection`](crate::model::OutboundConnection).
        pub fn build(self) -> crate::model::OutboundConnection {
            crate::model::OutboundConnection {
                connection_type: self.connection_type,
                connection_id: self.connection_id,
                subdirectory: self.subdirectory,
            }
        }
    }
}
impl OutboundConnection {
    /// Creates a new builder-style object to manufacture [`OutboundConnection`](crate::model::OutboundConnection).
    pub fn builder() -> crate::model::outbound_connection::Builder {
        crate::model::outbound_connection::Builder::default()
    }
}

/// When writing a match expression against `ConnectionType`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let connectiontype = unimplemented!();
/// match connectiontype {
///     ConnectionType::As2 => { /* ... */ },
///     ConnectionType::Bucket => { /* ... */ },
///     ConnectionType::RemoteFtp => { /* ... */ },
///     ConnectionType::StediFtp => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `connectiontype` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `ConnectionType::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `ConnectionType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `ConnectionType::NewFeature` is defined.
/// Specifically, when `connectiontype` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `ConnectionType::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum ConnectionType {
    #[allow(missing_docs)] // documentation missing in model
    As2,
    #[allow(missing_docs)] // documentation missing in model
    Bucket,
    #[allow(missing_docs)] // documentation missing in model
    RemoteFtp,
    #[allow(missing_docs)] // documentation missing in model
    StediFtp,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ConnectionType {
    fn from(s: &str) -> Self {
        match s {
            "as2" => ConnectionType::As2,
            "bucket" => ConnectionType::Bucket,
            "remote-ftp" => ConnectionType::RemoteFtp,
            "stedi-ftp" => ConnectionType::StediFtp,
            other => ConnectionType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for ConnectionType {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(ConnectionType::from(s))
    }
}
impl ConnectionType {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            ConnectionType::As2 => "as2",
            ConnectionType::Bucket => "bucket",
            ConnectionType::RemoteFtp => "remote-ftp",
            ConnectionType::StediFtp => "stedi-ftp",
            ConnectionType::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["as2", "bucket", "remote-ftp", "stedi-ftp"]
    }
}
impl AsRef<str> for ConnectionType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `X12FunctionalAcknowledgmentType`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let x12functionalacknowledgmenttype = unimplemented!();
/// match x12functionalacknowledgmenttype {
///     X12FunctionalAcknowledgmentType::Code997 => { /* ... */ },
///     X12FunctionalAcknowledgmentType::Code999 => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `x12functionalacknowledgmenttype` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `X12FunctionalAcknowledgmentType::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `X12FunctionalAcknowledgmentType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `X12FunctionalAcknowledgmentType::NewFeature` is defined.
/// Specifically, when `x12functionalacknowledgmenttype` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `X12FunctionalAcknowledgmentType::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
/// The transaction set to use when acknowledging a functional group.
///
/// code | description
/// -----|--------------------------
/// 997  | Used in all transaction sets. Not used to respond to a 997
/// 999  | Used in some healthcare transaction sets. Not used to respond to a 999.
///
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum X12FunctionalAcknowledgmentType {
    #[allow(missing_docs)] // documentation missing in model
    Code997,
    #[allow(missing_docs)] // documentation missing in model
    Code999,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for X12FunctionalAcknowledgmentType {
    fn from(s: &str) -> Self {
        match s {
            "997" => X12FunctionalAcknowledgmentType::Code997,
            "999" => X12FunctionalAcknowledgmentType::Code999,
            other => X12FunctionalAcknowledgmentType::Unknown(crate::types::UnknownVariantValue(
                other.to_owned(),
            )),
        }
    }
}
impl std::str::FromStr for X12FunctionalAcknowledgmentType {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(X12FunctionalAcknowledgmentType::from(s))
    }
}
impl X12FunctionalAcknowledgmentType {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            X12FunctionalAcknowledgmentType::Code997 => "997",
            X12FunctionalAcknowledgmentType::Code999 => "999",
            X12FunctionalAcknowledgmentType::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["997", "999"]
    }
}
impl AsRef<str> for X12FunctionalAcknowledgmentType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `X12TimeFormat`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let x12timeformat = unimplemented!();
/// match x12timeformat {
///     X12TimeFormat::Hhmm => { /* ... */ },
///     X12TimeFormat::Hhmmss => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `x12timeformat` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `X12TimeFormat::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `X12TimeFormat::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `X12TimeFormat::NewFeature` is defined.
/// Specifically, when `x12timeformat` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `X12TimeFormat::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum X12TimeFormat {
    #[allow(missing_docs)] // documentation missing in model
    Hhmm,
    #[allow(missing_docs)] // documentation missing in model
    Hhmmss,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for X12TimeFormat {
    fn from(s: &str) -> Self {
        match s {
            "HHMM" => X12TimeFormat::Hhmm,
            "HHMMSS" => X12TimeFormat::Hhmmss,
            other => X12TimeFormat::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for X12TimeFormat {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(X12TimeFormat::from(s))
    }
}
impl X12TimeFormat {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            X12TimeFormat::Hhmm => "HHMM",
            X12TimeFormat::Hhmmss => "HHMMSS",
            X12TimeFormat::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["HHMM", "HHMMSS"]
    }
}
impl AsRef<str> for X12TimeFormat {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `Timezone`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let timezone = unimplemented!();
/// match timezone {
///     Timezone::AmericaAdak => { /* ... */ },
///     Timezone::AmericaAnchorage => { /* ... */ },
///     Timezone::AmericaBoise => { /* ... */ },
///     Timezone::AmericaChicago => { /* ... */ },
///     Timezone::AmericaDenver => { /* ... */ },
///     Timezone::AmericaDetroit => { /* ... */ },
///     Timezone::AmericaIndianaIndianapolis => { /* ... */ },
///     Timezone::AmericaIndianaKnox => { /* ... */ },
///     Timezone::AmericaIndianaMarengo => { /* ... */ },
///     Timezone::AmericaIndianaPetersburg => { /* ... */ },
///     Timezone::AmericaIndianaTellCity => { /* ... */ },
///     Timezone::AmericaIndianaVevay => { /* ... */ },
///     Timezone::AmericaIndianaVincennes => { /* ... */ },
///     Timezone::AmericaIndianaWinamac => { /* ... */ },
///     Timezone::AmericaJuneau => { /* ... */ },
///     Timezone::AmericaKentuckyLouisville => { /* ... */ },
///     Timezone::AmericaKentuckyMonticello => { /* ... */ },
///     Timezone::AmericaLosAngeles => { /* ... */ },
///     Timezone::AmericaMenominee => { /* ... */ },
///     Timezone::AmericaMetlakatla => { /* ... */ },
///     Timezone::AmericaNewYork => { /* ... */ },
///     Timezone::AmericaNome => { /* ... */ },
///     Timezone::AmericaNorthDakotaBeulah => { /* ... */ },
///     Timezone::AmericaNorthDakotaCenter => { /* ... */ },
///     Timezone::AmericaNorthDakotaNewSalem => { /* ... */ },
///     Timezone::AmericaPhoenix => { /* ... */ },
///     Timezone::AmericaSitka => { /* ... */ },
///     Timezone::AmericaYakutat => { /* ... */ },
///     Timezone::PacificHonolulu => { /* ... */ },
///     Timezone::Utc => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `timezone` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `Timezone::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `Timezone::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `Timezone::NewFeature` is defined.
/// Specifically, when `timezone` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `Timezone::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum Timezone {
    #[allow(missing_docs)] // documentation missing in model
    AmericaAdak,
    #[allow(missing_docs)] // documentation missing in model
    AmericaAnchorage,
    #[allow(missing_docs)] // documentation missing in model
    AmericaBoise,
    #[allow(missing_docs)] // documentation missing in model
    AmericaChicago,
    #[allow(missing_docs)] // documentation missing in model
    AmericaDenver,
    #[allow(missing_docs)] // documentation missing in model
    AmericaDetroit,
    #[allow(missing_docs)] // documentation missing in model
    AmericaIndianaIndianapolis,
    #[allow(missing_docs)] // documentation missing in model
    AmericaIndianaKnox,
    #[allow(missing_docs)] // documentation missing in model
    AmericaIndianaMarengo,
    #[allow(missing_docs)] // documentation missing in model
    AmericaIndianaPetersburg,
    #[allow(missing_docs)] // documentation missing in model
    AmericaIndianaTellCity,
    #[allow(missing_docs)] // documentation missing in model
    AmericaIndianaVevay,
    #[allow(missing_docs)] // documentation missing in model
    AmericaIndianaVincennes,
    #[allow(missing_docs)] // documentation missing in model
    AmericaIndianaWinamac,
    #[allow(missing_docs)] // documentation missing in model
    AmericaJuneau,
    #[allow(missing_docs)] // documentation missing in model
    AmericaKentuckyLouisville,
    #[allow(missing_docs)] // documentation missing in model
    AmericaKentuckyMonticello,
    #[allow(missing_docs)] // documentation missing in model
    AmericaLosAngeles,
    #[allow(missing_docs)] // documentation missing in model
    AmericaMenominee,
    #[allow(missing_docs)] // documentation missing in model
    AmericaMetlakatla,
    #[allow(missing_docs)] // documentation missing in model
    AmericaNewYork,
    #[allow(missing_docs)] // documentation missing in model
    AmericaNome,
    #[allow(missing_docs)] // documentation missing in model
    AmericaNorthDakotaBeulah,
    #[allow(missing_docs)] // documentation missing in model
    AmericaNorthDakotaCenter,
    #[allow(missing_docs)] // documentation missing in model
    AmericaNorthDakotaNewSalem,
    #[allow(missing_docs)] // documentation missing in model
    AmericaPhoenix,
    #[allow(missing_docs)] // documentation missing in model
    AmericaSitka,
    #[allow(missing_docs)] // documentation missing in model
    AmericaYakutat,
    #[allow(missing_docs)] // documentation missing in model
    PacificHonolulu,
    #[allow(missing_docs)] // documentation missing in model
    Utc,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for Timezone {
    fn from(s: &str) -> Self {
        match s {
            "America/Adak" => Timezone::AmericaAdak,
            "America/Anchorage" => Timezone::AmericaAnchorage,
            "America/Boise" => Timezone::AmericaBoise,
            "America/Chicago" => Timezone::AmericaChicago,
            "America/Denver" => Timezone::AmericaDenver,
            "America/Detroit" => Timezone::AmericaDetroit,
            "America/Indiana/Indianapolis" => Timezone::AmericaIndianaIndianapolis,
            "America/Indiana/Knox" => Timezone::AmericaIndianaKnox,
            "America/Indiana/Marengo" => Timezone::AmericaIndianaMarengo,
            "America/Indiana/Petersburg" => Timezone::AmericaIndianaPetersburg,
            "America/Indiana/Tell_City" => Timezone::AmericaIndianaTellCity,
            "America/Indiana/Vevay" => Timezone::AmericaIndianaVevay,
            "America/Indiana/Vincennes" => Timezone::AmericaIndianaVincennes,
            "America/Indiana/Winamac" => Timezone::AmericaIndianaWinamac,
            "America/Juneau" => Timezone::AmericaJuneau,
            "America/Kentucky/Louisville" => Timezone::AmericaKentuckyLouisville,
            "America/Kentucky/Monticello" => Timezone::AmericaKentuckyMonticello,
            "America/Los_Angeles" => Timezone::AmericaLosAngeles,
            "America/Menominee" => Timezone::AmericaMenominee,
            "America/Metlakatla" => Timezone::AmericaMetlakatla,
            "America/New_York" => Timezone::AmericaNewYork,
            "America/Nome" => Timezone::AmericaNome,
            "America/North_Dakota/Beulah" => Timezone::AmericaNorthDakotaBeulah,
            "America/North_Dakota/Center" => Timezone::AmericaNorthDakotaCenter,
            "America/North_Dakota/New_Salem" => Timezone::AmericaNorthDakotaNewSalem,
            "America/Phoenix" => Timezone::AmericaPhoenix,
            "America/Sitka" => Timezone::AmericaSitka,
            "America/Yakutat" => Timezone::AmericaYakutat,
            "Pacific/Honolulu" => Timezone::PacificHonolulu,
            "UTC" => Timezone::Utc,
            other => Timezone::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for Timezone {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(Timezone::from(s))
    }
}
impl Timezone {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            Timezone::AmericaAdak => "America/Adak",
            Timezone::AmericaAnchorage => "America/Anchorage",
            Timezone::AmericaBoise => "America/Boise",
            Timezone::AmericaChicago => "America/Chicago",
            Timezone::AmericaDenver => "America/Denver",
            Timezone::AmericaDetroit => "America/Detroit",
            Timezone::AmericaIndianaIndianapolis => "America/Indiana/Indianapolis",
            Timezone::AmericaIndianaKnox => "America/Indiana/Knox",
            Timezone::AmericaIndianaMarengo => "America/Indiana/Marengo",
            Timezone::AmericaIndianaPetersburg => "America/Indiana/Petersburg",
            Timezone::AmericaIndianaTellCity => "America/Indiana/Tell_City",
            Timezone::AmericaIndianaVevay => "America/Indiana/Vevay",
            Timezone::AmericaIndianaVincennes => "America/Indiana/Vincennes",
            Timezone::AmericaIndianaWinamac => "America/Indiana/Winamac",
            Timezone::AmericaJuneau => "America/Juneau",
            Timezone::AmericaKentuckyLouisville => "America/Kentucky/Louisville",
            Timezone::AmericaKentuckyMonticello => "America/Kentucky/Monticello",
            Timezone::AmericaLosAngeles => "America/Los_Angeles",
            Timezone::AmericaMenominee => "America/Menominee",
            Timezone::AmericaMetlakatla => "America/Metlakatla",
            Timezone::AmericaNewYork => "America/New_York",
            Timezone::AmericaNome => "America/Nome",
            Timezone::AmericaNorthDakotaBeulah => "America/North_Dakota/Beulah",
            Timezone::AmericaNorthDakotaCenter => "America/North_Dakota/Center",
            Timezone::AmericaNorthDakotaNewSalem => "America/North_Dakota/New_Salem",
            Timezone::AmericaPhoenix => "America/Phoenix",
            Timezone::AmericaSitka => "America/Sitka",
            Timezone::AmericaYakutat => "America/Yakutat",
            Timezone::PacificHonolulu => "Pacific/Honolulu",
            Timezone::Utc => "UTC",
            Timezone::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "America/Adak",
            "America/Anchorage",
            "America/Boise",
            "America/Chicago",
            "America/Denver",
            "America/Detroit",
            "America/Indiana/Indianapolis",
            "America/Indiana/Knox",
            "America/Indiana/Marengo",
            "America/Indiana/Petersburg",
            "America/Indiana/Tell_City",
            "America/Indiana/Vevay",
            "America/Indiana/Vincennes",
            "America/Indiana/Winamac",
            "America/Juneau",
            "America/Kentucky/Louisville",
            "America/Kentucky/Monticello",
            "America/Los_Angeles",
            "America/Menominee",
            "America/Metlakatla",
            "America/New_York",
            "America/Nome",
            "America/North_Dakota/Beulah",
            "America/North_Dakota/Center",
            "America/North_Dakota/New_Salem",
            "America/Phoenix",
            "America/Sitka",
            "America/Yakutat",
            "Pacific/Honolulu",
            "UTC",
        ]
    }
}
impl AsRef<str> for Timezone {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `X12UsageIndicator`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let x12usageindicator = unimplemented!();
/// match x12usageindicator {
///     X12UsageIndicator::Information => { /* ... */ },
///     X12UsageIndicator::Production => { /* ... */ },
///     X12UsageIndicator::Test => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `x12usageindicator` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `X12UsageIndicator::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `X12UsageIndicator::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `X12UsageIndicator::NewFeature` is defined.
/// Specifically, when `x12usageindicator` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `X12UsageIndicator::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum X12UsageIndicator {
    #[allow(missing_docs)] // documentation missing in model
    Information,
    #[allow(missing_docs)] // documentation missing in model
    Production,
    #[allow(missing_docs)] // documentation missing in model
    Test,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for X12UsageIndicator {
    fn from(s: &str) -> Self {
        match s {
            "I" => X12UsageIndicator::Information,
            "P" => X12UsageIndicator::Production,
            "T" => X12UsageIndicator::Test,
            other => {
                X12UsageIndicator::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
            }
        }
    }
}
impl std::str::FromStr for X12UsageIndicator {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(X12UsageIndicator::from(s))
    }
}
impl X12UsageIndicator {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            X12UsageIndicator::Information => "I",
            X12UsageIndicator::Production => "P",
            X12UsageIndicator::Test => "T",
            X12UsageIndicator::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["I", "P", "T"]
    }
}
impl AsRef<str> for X12UsageIndicator {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct OutboundX12TransactionSettingsSummary {
    #[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 created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
}
impl OutboundX12TransactionSettingsSummary {
    #[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 created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.as_ref()
    }
}
/// See [`OutboundX12TransactionSettingsSummary`](crate::model::OutboundX12TransactionSettingsSummary).
pub mod outbound_x12_transaction_settings_summary {

    /// A builder for [`OutboundX12TransactionSettingsSummary`](crate::model::OutboundX12TransactionSettingsSummary).
    #[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) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
    }
    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 created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = input;
            self
        }
        /// Consumes the builder and constructs a [`OutboundX12TransactionSettingsSummary`](crate::model::OutboundX12TransactionSettingsSummary).
        pub fn build(self) -> crate::model::OutboundX12TransactionSettingsSummary {
            crate::model::OutboundX12TransactionSettingsSummary {
                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,
                created_at: self.created_at,
                updated_at: self.updated_at,
            }
        }
    }
}
impl OutboundX12TransactionSettingsSummary {
    /// Creates a new builder-style object to manufacture [`OutboundX12TransactionSettingsSummary`](crate::model::OutboundX12TransactionSettingsSummary).
    pub fn builder() -> crate::model::outbound_x12_transaction_settings_summary::Builder {
        crate::model::outbound_x12_transaction_settings_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InboundX12TransactionSettingsSummary {
    #[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: 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 created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub inbound_x12_transaction_settings_id: std::option::Option<std::string::String>,
}
impl InboundX12TransactionSettingsSummary {
    #[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) -> 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 created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.as_ref()
    }
    #[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()
    }
}
/// See [`InboundX12TransactionSettingsSummary`](crate::model::InboundX12TransactionSettingsSummary).
pub mod inbound_x12_transaction_settings_summary {

    /// A builder for [`InboundX12TransactionSettingsSummary`](crate::model::InboundX12TransactionSettingsSummary).
    #[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) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
        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 created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = 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 [`InboundX12TransactionSettingsSummary`](crate::model::InboundX12TransactionSettingsSummary).
        pub fn build(self) -> crate::model::InboundX12TransactionSettingsSummary {
            crate::model::InboundX12TransactionSettingsSummary {
                release: self.release,
                transaction_set_identifier: self.transaction_set_identifier,
                guide_id: self.guide_id,
                enable_fragments: self.enable_fragments.unwrap_or_default(),
                fragment_size: self.fragment_size,
                created_at: self.created_at,
                updated_at: self.updated_at,
                inbound_x12_transaction_settings_id: self.inbound_x12_transaction_settings_id,
            }
        }
    }
}
impl InboundX12TransactionSettingsSummary {
    /// Creates a new builder-style object to manufacture [`InboundX12TransactionSettingsSummary`](crate::model::InboundX12TransactionSettingsSummary).
    pub fn builder() -> crate::model::inbound_x12_transaction_settings_summary::Builder {
        crate::model::inbound_x12_transaction_settings_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct X12ProfileFields {
    #[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 X12ProfileFields {
    #[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()
    }
}
/// See [`X12ProfileFields`](crate::model::X12ProfileFields).
pub mod x12_profile_fields {

    /// A builder for [`X12ProfileFields`](crate::model::X12ProfileFields).
    #[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 [`X12ProfileFields`](crate::model::X12ProfileFields).
        pub fn build(self) -> crate::model::X12ProfileFields {
            crate::model::X12ProfileFields {
                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 X12ProfileFields {
    /// Creates a new builder-style object to manufacture [`X12ProfileFields`](crate::model::X12ProfileFields).
    pub fn builder() -> crate::model::x12_profile_fields::Builder {
        crate::model::x12_profile_fields::Builder::default()
    }
}

/// When writing a match expression against `StackStatus`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let stackstatus = unimplemented!();
/// match stackstatus {
///     StackStatus::Available => { /* ... */ },
///     StackStatus::Creating => { /* ... */ },
///     StackStatus::Deleted => { /* ... */ },
///     StackStatus::Deleting => { /* ... */ },
///     StackStatus::Failed => { /* ... */ },
///     StackStatus::UnknownValue => { /* ... */ },
///     StackStatus::Updating => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `stackstatus` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `StackStatus::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `StackStatus::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `StackStatus::NewFeature` is defined.
/// Specifically, when `stackstatus` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `StackStatus::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
/// Connection Status
///
/// _Note: `StackStatus::Unknown` has been renamed to `::UnknownValue`._
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum StackStatus {
    #[allow(missing_docs)] // documentation missing in model
    Available,
    #[allow(missing_docs)] // documentation missing in model
    Creating,
    #[allow(missing_docs)] // documentation missing in model
    Deleted,
    #[allow(missing_docs)] // documentation missing in model
    Deleting,
    #[allow(missing_docs)] // documentation missing in model
    Failed,
    /// _Note: `::Unknown` has been renamed to `::UnknownValue`._
    UnknownValue,
    #[allow(missing_docs)] // documentation missing in model
    Updating,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for StackStatus {
    fn from(s: &str) -> Self {
        match s {
            "Available" => StackStatus::Available,
            "Creating" => StackStatus::Creating,
            "Deleted" => StackStatus::Deleted,
            "Deleting" => StackStatus::Deleting,
            "Failed" => StackStatus::Failed,
            "Unknown" => StackStatus::UnknownValue,
            "Updating" => StackStatus::Updating,
            other => StackStatus::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for StackStatus {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(StackStatus::from(s))
    }
}
impl StackStatus {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            StackStatus::Available => "Available",
            StackStatus::Creating => "Creating",
            StackStatus::Deleted => "Deleted",
            StackStatus::Deleting => "Deleting",
            StackStatus::Failed => "Failed",
            StackStatus::UnknownValue => "Unknown",
            StackStatus::Updating => "Updating",
            StackStatus::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "Available",
            "Creating",
            "Deleted",
            "Deleting",
            "Failed",
            "Unknown",
            "Updating",
        ]
    }
}
impl AsRef<str> for StackStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RemoteFtpAlgorithms {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub kex: std::option::Option<std::vec::Vec<crate::model::Kex>>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub cipher: std::option::Option<std::vec::Vec<crate::model::Cipher>>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub server_host_key: std::option::Option<std::vec::Vec<crate::model::ServerHostKey>>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub hmac: std::option::Option<std::vec::Vec<crate::model::Hmac>>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub compress: std::option::Option<std::vec::Vec<crate::model::Compression>>,
}
impl RemoteFtpAlgorithms {
    #[allow(missing_docs)] // documentation missing in model
    pub fn kex(&self) -> std::option::Option<&[crate::model::Kex]> {
        self.kex.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn cipher(&self) -> std::option::Option<&[crate::model::Cipher]> {
        self.cipher.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn server_host_key(&self) -> std::option::Option<&[crate::model::ServerHostKey]> {
        self.server_host_key.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn hmac(&self) -> std::option::Option<&[crate::model::Hmac]> {
        self.hmac.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn compress(&self) -> std::option::Option<&[crate::model::Compression]> {
        self.compress.as_deref()
    }
}
/// See [`RemoteFtpAlgorithms`](crate::model::RemoteFtpAlgorithms).
pub mod remote_ftp_algorithms {

    /// A builder for [`RemoteFtpAlgorithms`](crate::model::RemoteFtpAlgorithms).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) kex: std::option::Option<std::vec::Vec<crate::model::Kex>>,
        pub(crate) cipher: std::option::Option<std::vec::Vec<crate::model::Cipher>>,
        pub(crate) server_host_key: std::option::Option<std::vec::Vec<crate::model::ServerHostKey>>,
        pub(crate) hmac: std::option::Option<std::vec::Vec<crate::model::Hmac>>,
        pub(crate) compress: std::option::Option<std::vec::Vec<crate::model::Compression>>,
    }
    impl Builder {
        /// Appends an item to `kex`.
        ///
        /// To override the contents of this collection use [`set_kex`](Self::set_kex).
        ///
        pub fn kex(mut self, input: crate::model::Kex) -> Self {
            let mut v = self.kex.unwrap_or_default();
            v.push(input);
            self.kex = Some(v);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_kex(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Kex>>,
        ) -> Self {
            self.kex = input;
            self
        }
        /// Appends an item to `cipher`.
        ///
        /// To override the contents of this collection use [`set_cipher`](Self::set_cipher).
        ///
        pub fn cipher(mut self, input: crate::model::Cipher) -> Self {
            let mut v = self.cipher.unwrap_or_default();
            v.push(input);
            self.cipher = Some(v);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_cipher(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Cipher>>,
        ) -> Self {
            self.cipher = input;
            self
        }
        /// Appends an item to `server_host_key`.
        ///
        /// To override the contents of this collection use [`set_server_host_key`](Self::set_server_host_key).
        ///
        pub fn server_host_key(mut self, input: crate::model::ServerHostKey) -> Self {
            let mut v = self.server_host_key.unwrap_or_default();
            v.push(input);
            self.server_host_key = Some(v);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_server_host_key(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ServerHostKey>>,
        ) -> Self {
            self.server_host_key = input;
            self
        }
        /// Appends an item to `hmac`.
        ///
        /// To override the contents of this collection use [`set_hmac`](Self::set_hmac).
        ///
        pub fn hmac(mut self, input: crate::model::Hmac) -> Self {
            let mut v = self.hmac.unwrap_or_default();
            v.push(input);
            self.hmac = Some(v);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_hmac(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Hmac>>,
        ) -> Self {
            self.hmac = input;
            self
        }
        /// Appends an item to `compress`.
        ///
        /// To override the contents of this collection use [`set_compress`](Self::set_compress).
        ///
        pub fn compress(mut self, input: crate::model::Compression) -> Self {
            let mut v = self.compress.unwrap_or_default();
            v.push(input);
            self.compress = Some(v);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_compress(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Compression>>,
        ) -> Self {
            self.compress = input;
            self
        }
        /// Consumes the builder and constructs a [`RemoteFtpAlgorithms`](crate::model::RemoteFtpAlgorithms).
        pub fn build(self) -> crate::model::RemoteFtpAlgorithms {
            crate::model::RemoteFtpAlgorithms {
                kex: self.kex,
                cipher: self.cipher,
                server_host_key: self.server_host_key,
                hmac: self.hmac,
                compress: self.compress,
            }
        }
    }
}
impl RemoteFtpAlgorithms {
    /// Creates a new builder-style object to manufacture [`RemoteFtpAlgorithms`](crate::model::RemoteFtpAlgorithms).
    pub fn builder() -> crate::model::remote_ftp_algorithms::Builder {
        crate::model::remote_ftp_algorithms::Builder::default()
    }
}

/// When writing a match expression against `Compression`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let compression = unimplemented!();
/// match compression {
///     Compression::None => { /* ... */ },
///     Compression::Zlib => { /* ... */ },
///     Compression::ZlibOpenSsh => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `compression` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `Compression::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `Compression::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `Compression::NewFeature` is defined.
/// Specifically, when `compression` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `Compression::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum Compression {
    #[allow(missing_docs)] // documentation missing in model
    None,
    #[allow(missing_docs)] // documentation missing in model
    Zlib,
    #[allow(missing_docs)] // documentation missing in model
    ZlibOpenSsh,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for Compression {
    fn from(s: &str) -> Self {
        match s {
            "none" => Compression::None,
            "zlib" => Compression::Zlib,
            "zlib@openssh.com" => Compression::ZlibOpenSsh,
            other => Compression::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for Compression {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(Compression::from(s))
    }
}
impl Compression {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            Compression::None => "none",
            Compression::Zlib => "zlib",
            Compression::ZlibOpenSsh => "zlib@openssh.com",
            Compression::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["none", "zlib", "zlib@openssh.com"]
    }
}
impl AsRef<str> for Compression {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `Hmac`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let hmac = unimplemented!();
/// match hmac {
///     Hmac::Md5 => { /* ... */ },
///     Hmac::Md596 => { /* ... */ },
///     Hmac::Ropemd160 => { /* ... */ },
///     Hmac::Sha1 => { /* ... */ },
///     Hmac::Sha196 => { /* ... */ },
///     Hmac::Sha1Openssh => { /* ... */ },
///     Hmac::Sha2256 => { /* ... */ },
///     Hmac::Sha225696 => { /* ... */ },
///     Hmac::Sha2256Openssh => { /* ... */ },
///     Hmac::Sha2512 => { /* ... */ },
///     Hmac::Sha251296 => { /* ... */ },
///     Hmac::Sha2512Openssh => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `hmac` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `Hmac::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `Hmac::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `Hmac::NewFeature` is defined.
/// Specifically, when `hmac` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `Hmac::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum Hmac {
    #[allow(missing_docs)] // documentation missing in model
    Md5,
    #[allow(missing_docs)] // documentation missing in model
    Md596,
    #[allow(missing_docs)] // documentation missing in model
    Ropemd160,
    #[allow(missing_docs)] // documentation missing in model
    Sha1,
    #[allow(missing_docs)] // documentation missing in model
    Sha196,
    #[allow(missing_docs)] // documentation missing in model
    Sha1Openssh,
    #[allow(missing_docs)] // documentation missing in model
    Sha2256,
    #[allow(missing_docs)] // documentation missing in model
    Sha225696,
    #[allow(missing_docs)] // documentation missing in model
    Sha2256Openssh,
    #[allow(missing_docs)] // documentation missing in model
    Sha2512,
    #[allow(missing_docs)] // documentation missing in model
    Sha251296,
    #[allow(missing_docs)] // documentation missing in model
    Sha2512Openssh,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for Hmac {
    fn from(s: &str) -> Self {
        match s {
            "hmac-md5" => Hmac::Md5,
            "hmac-md5-96" => Hmac::Md596,
            "hmac-ripemd160" => Hmac::Ropemd160,
            "hmac-sha1" => Hmac::Sha1,
            "hmac-sha1-96" => Hmac::Sha196,
            "hmac-sha1-etm@openssh.com" => Hmac::Sha1Openssh,
            "hmac-sha2-256" => Hmac::Sha2256,
            "hmac-sha2-256-96" => Hmac::Sha225696,
            "hmac-sha2-256-etm@openssh.com" => Hmac::Sha2256Openssh,
            "hmac-sha2-512" => Hmac::Sha2512,
            "hmac-sha2-512-96" => Hmac::Sha251296,
            "hmac-sha2-512-etm@openssh.com" => Hmac::Sha2512Openssh,
            other => Hmac::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for Hmac {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(Hmac::from(s))
    }
}
impl Hmac {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            Hmac::Md5 => "hmac-md5",
            Hmac::Md596 => "hmac-md5-96",
            Hmac::Ropemd160 => "hmac-ripemd160",
            Hmac::Sha1 => "hmac-sha1",
            Hmac::Sha196 => "hmac-sha1-96",
            Hmac::Sha1Openssh => "hmac-sha1-etm@openssh.com",
            Hmac::Sha2256 => "hmac-sha2-256",
            Hmac::Sha225696 => "hmac-sha2-256-96",
            Hmac::Sha2256Openssh => "hmac-sha2-256-etm@openssh.com",
            Hmac::Sha2512 => "hmac-sha2-512",
            Hmac::Sha251296 => "hmac-sha2-512-96",
            Hmac::Sha2512Openssh => "hmac-sha2-512-etm@openssh.com",
            Hmac::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "hmac-md5",
            "hmac-md5-96",
            "hmac-ripemd160",
            "hmac-sha1",
            "hmac-sha1-96",
            "hmac-sha1-etm@openssh.com",
            "hmac-sha2-256",
            "hmac-sha2-256-96",
            "hmac-sha2-256-etm@openssh.com",
            "hmac-sha2-512",
            "hmac-sha2-512-96",
            "hmac-sha2-512-etm@openssh.com",
        ]
    }
}
impl AsRef<str> for Hmac {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `ServerHostKey`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let serverhostkey = unimplemented!();
/// match serverhostkey {
///     ServerHostKey::EcdsaSha2256 => { /* ... */ },
///     ServerHostKey::EcdsaSha2384 => { /* ... */ },
///     ServerHostKey::EcdsaSha2512 => { /* ... */ },
///     ServerHostKey::Rsa256 => { /* ... */ },
///     ServerHostKey::Rsa512 => { /* ... */ },
///     ServerHostKey::SshDss => { /* ... */ },
///     ServerHostKey::SshEd25519 => { /* ... */ },
///     ServerHostKey::SshRsa => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `serverhostkey` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `ServerHostKey::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `ServerHostKey::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `ServerHostKey::NewFeature` is defined.
/// Specifically, when `serverhostkey` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `ServerHostKey::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum ServerHostKey {
    #[allow(missing_docs)] // documentation missing in model
    EcdsaSha2256,
    #[allow(missing_docs)] // documentation missing in model
    EcdsaSha2384,
    #[allow(missing_docs)] // documentation missing in model
    EcdsaSha2512,
    #[allow(missing_docs)] // documentation missing in model
    Rsa256,
    #[allow(missing_docs)] // documentation missing in model
    Rsa512,
    #[allow(missing_docs)] // documentation missing in model
    SshDss,
    #[allow(missing_docs)] // documentation missing in model
    SshEd25519,
    #[allow(missing_docs)] // documentation missing in model
    SshRsa,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ServerHostKey {
    fn from(s: &str) -> Self {
        match s {
            "ecdsa-sha2-nistp256" => ServerHostKey::EcdsaSha2256,
            "ecdsa-sha2-nistp384" => ServerHostKey::EcdsaSha2384,
            "ecdsa-sha2-nistp521" => ServerHostKey::EcdsaSha2512,
            "rsa-sha2-256" => ServerHostKey::Rsa256,
            "rsa-sha2-512" => ServerHostKey::Rsa512,
            "ssh-dss" => ServerHostKey::SshDss,
            "ssh-ed25519" => ServerHostKey::SshEd25519,
            "ssh-rsa" => ServerHostKey::SshRsa,
            other => ServerHostKey::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for ServerHostKey {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(ServerHostKey::from(s))
    }
}
impl ServerHostKey {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            ServerHostKey::EcdsaSha2256 => "ecdsa-sha2-nistp256",
            ServerHostKey::EcdsaSha2384 => "ecdsa-sha2-nistp384",
            ServerHostKey::EcdsaSha2512 => "ecdsa-sha2-nistp521",
            ServerHostKey::Rsa256 => "rsa-sha2-256",
            ServerHostKey::Rsa512 => "rsa-sha2-512",
            ServerHostKey::SshDss => "ssh-dss",
            ServerHostKey::SshEd25519 => "ssh-ed25519",
            ServerHostKey::SshRsa => "ssh-rsa",
            ServerHostKey::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "ecdsa-sha2-nistp256",
            "ecdsa-sha2-nistp384",
            "ecdsa-sha2-nistp521",
            "rsa-sha2-256",
            "rsa-sha2-512",
            "ssh-dss",
            "ssh-ed25519",
            "ssh-rsa",
        ]
    }
}
impl AsRef<str> for ServerHostKey {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `Cipher`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let cipher = unimplemented!();
/// match cipher {
///     Cipher::ThreeDes => { /* ... */ },
///     Cipher::Aes128Cbc => { /* ... */ },
///     Cipher::Aes128Ctr => { /* ... */ },
///     Cipher::Aes128Gcm => { /* ... */ },
///     Cipher::Aes128GcmOpenssh => { /* ... */ },
///     Cipher::Aes192Cbc => { /* ... */ },
///     Cipher::Aes192Ctr => { /* ... */ },
///     Cipher::Aes256Cbc => { /* ... */ },
///     Cipher::Aes256Ctr => { /* ... */ },
///     Cipher::Aes256Gcm => { /* ... */ },
///     Cipher::Aes256GcmOpenssh => { /* ... */ },
///     Cipher::Arcfour => { /* ... */ },
///     Cipher::Arcfour128 => { /* ... */ },
///     Cipher::Arcfour256 => { /* ... */ },
///     Cipher::Blowfish => { /* ... */ },
///     Cipher::Cast128 => { /* ... */ },
///     Cipher::ChaCha20 => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `cipher` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `Cipher::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `Cipher::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `Cipher::NewFeature` is defined.
/// Specifically, when `cipher` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `Cipher::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum Cipher {
    #[allow(missing_docs)] // documentation missing in model
    ThreeDes,
    #[allow(missing_docs)] // documentation missing in model
    Aes128Cbc,
    #[allow(missing_docs)] // documentation missing in model
    Aes128Ctr,
    #[allow(missing_docs)] // documentation missing in model
    Aes128Gcm,
    #[allow(missing_docs)] // documentation missing in model
    Aes128GcmOpenssh,
    #[allow(missing_docs)] // documentation missing in model
    Aes192Cbc,
    #[allow(missing_docs)] // documentation missing in model
    Aes192Ctr,
    #[allow(missing_docs)] // documentation missing in model
    Aes256Cbc,
    #[allow(missing_docs)] // documentation missing in model
    Aes256Ctr,
    #[allow(missing_docs)] // documentation missing in model
    Aes256Gcm,
    #[allow(missing_docs)] // documentation missing in model
    Aes256GcmOpenssh,
    #[allow(missing_docs)] // documentation missing in model
    Arcfour,
    #[allow(missing_docs)] // documentation missing in model
    Arcfour128,
    #[allow(missing_docs)] // documentation missing in model
    Arcfour256,
    #[allow(missing_docs)] // documentation missing in model
    Blowfish,
    #[allow(missing_docs)] // documentation missing in model
    Cast128,
    #[allow(missing_docs)] // documentation missing in model
    ChaCha20,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for Cipher {
    fn from(s: &str) -> Self {
        match s {
            "3des-cbc" => Cipher::ThreeDes,
            "aes128-cbc" => Cipher::Aes128Cbc,
            "aes128-ctr" => Cipher::Aes128Ctr,
            "aes128-gcm" => Cipher::Aes128Gcm,
            "aes128-gcm@openssh.com" => Cipher::Aes128GcmOpenssh,
            "aes192-cbc" => Cipher::Aes192Cbc,
            "aes192-ctr" => Cipher::Aes192Ctr,
            "aes256-cbc" => Cipher::Aes256Cbc,
            "aes256-ctr" => Cipher::Aes256Ctr,
            "aes256-gcm" => Cipher::Aes256Gcm,
            "aes256-gcm@openssh.com" => Cipher::Aes256GcmOpenssh,
            "arcfour" => Cipher::Arcfour,
            "arcfour128" => Cipher::Arcfour128,
            "arcfour256" => Cipher::Arcfour256,
            "blowfish-cbc" => Cipher::Blowfish,
            "cast128-cbc" => Cipher::Cast128,
            "chacha20-poly1305@openssh.com" => Cipher::ChaCha20,
            other => Cipher::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for Cipher {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(Cipher::from(s))
    }
}
impl Cipher {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            Cipher::ThreeDes => "3des-cbc",
            Cipher::Aes128Cbc => "aes128-cbc",
            Cipher::Aes128Ctr => "aes128-ctr",
            Cipher::Aes128Gcm => "aes128-gcm",
            Cipher::Aes128GcmOpenssh => "aes128-gcm@openssh.com",
            Cipher::Aes192Cbc => "aes192-cbc",
            Cipher::Aes192Ctr => "aes192-ctr",
            Cipher::Aes256Cbc => "aes256-cbc",
            Cipher::Aes256Ctr => "aes256-ctr",
            Cipher::Aes256Gcm => "aes256-gcm",
            Cipher::Aes256GcmOpenssh => "aes256-gcm@openssh.com",
            Cipher::Arcfour => "arcfour",
            Cipher::Arcfour128 => "arcfour128",
            Cipher::Arcfour256 => "arcfour256",
            Cipher::Blowfish => "blowfish-cbc",
            Cipher::Cast128 => "cast128-cbc",
            Cipher::ChaCha20 => "chacha20-poly1305@openssh.com",
            Cipher::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "3des-cbc",
            "aes128-cbc",
            "aes128-ctr",
            "aes128-gcm",
            "aes128-gcm@openssh.com",
            "aes192-cbc",
            "aes192-ctr",
            "aes256-cbc",
            "aes256-ctr",
            "aes256-gcm",
            "aes256-gcm@openssh.com",
            "arcfour",
            "arcfour128",
            "arcfour256",
            "blowfish-cbc",
            "cast128-cbc",
            "chacha20-poly1305@openssh.com",
        ]
    }
}
impl AsRef<str> for Cipher {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `Kex`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let kex = unimplemented!();
/// match kex {
///     Kex::Curve25519 => { /* ... */ },
///     Kex::Curve25519Libssh => { /* ... */ },
///     Kex::DiffieGroupExcSha1 => { /* ... */ },
///     Kex::DiffieGroupSha256 => { /* ... */ },
///     Kex::DiffieGroup1Sha1 => { /* ... */ },
///     Kex::DiffieGroup14Sha1 => { /* ... */ },
///     Kex::DiffieGroup14Sha256 => { /* ... */ },
///     Kex::DiffieGroup15Sha512 => { /* ... */ },
///     Kex::DiffieGroup16Sha512 => { /* ... */ },
///     Kex::DiffieGroup17Sha512 => { /* ... */ },
///     Kex::DiffieGroup18Sha512 => { /* ... */ },
///     Kex::EcdhSha2256 => { /* ... */ },
///     Kex::EcdhSha2384 => { /* ... */ },
///     Kex::EcdhSha2521 => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `kex` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `Kex::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `Kex::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `Kex::NewFeature` is defined.
/// Specifically, when `kex` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `Kex::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum Kex {
    #[allow(missing_docs)] // documentation missing in model
    Curve25519,
    #[allow(missing_docs)] // documentation missing in model
    Curve25519Libssh,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroupExcSha1,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroupSha256,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroup1Sha1,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroup14Sha1,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroup14Sha256,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroup15Sha512,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroup16Sha512,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroup17Sha512,
    #[allow(missing_docs)] // documentation missing in model
    DiffieGroup18Sha512,
    #[allow(missing_docs)] // documentation missing in model
    EcdhSha2256,
    #[allow(missing_docs)] // documentation missing in model
    EcdhSha2384,
    #[allow(missing_docs)] // documentation missing in model
    EcdhSha2521,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for Kex {
    fn from(s: &str) -> Self {
        match s {
            "curve25519-sha256" => Kex::Curve25519,
            "curve25519-sha256@libssh.org" => Kex::Curve25519Libssh,
            "diffie-hellman-group-exchange-sha1" => Kex::DiffieGroupExcSha1,
            "diffie-hellman-group-exchange-sha256" => Kex::DiffieGroupSha256,
            "diffie-hellman-group1-sha1" => Kex::DiffieGroup1Sha1,
            "diffie-hellman-group14-sha1" => Kex::DiffieGroup14Sha1,
            "diffie-hellman-group14-sha256" => Kex::DiffieGroup14Sha256,
            "diffie-hellman-group15-sha512" => Kex::DiffieGroup15Sha512,
            "diffie-hellman-group16-sha512" => Kex::DiffieGroup16Sha512,
            "diffie-hellman-group17-sha512" => Kex::DiffieGroup17Sha512,
            "diffie-hellman-group18-sha512" => Kex::DiffieGroup18Sha512,
            "ecdh-sha2-nistp256" => Kex::EcdhSha2256,
            "ecdh-sha2-nistp384" => Kex::EcdhSha2384,
            "ecdh-sha2-nistp521" => Kex::EcdhSha2521,
            other => Kex::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for Kex {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(Kex::from(s))
    }
}
impl Kex {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            Kex::Curve25519 => "curve25519-sha256",
            Kex::Curve25519Libssh => "curve25519-sha256@libssh.org",
            Kex::DiffieGroupExcSha1 => "diffie-hellman-group-exchange-sha1",
            Kex::DiffieGroupSha256 => "diffie-hellman-group-exchange-sha256",
            Kex::DiffieGroup1Sha1 => "diffie-hellman-group1-sha1",
            Kex::DiffieGroup14Sha1 => "diffie-hellman-group14-sha1",
            Kex::DiffieGroup14Sha256 => "diffie-hellman-group14-sha256",
            Kex::DiffieGroup15Sha512 => "diffie-hellman-group15-sha512",
            Kex::DiffieGroup16Sha512 => "diffie-hellman-group16-sha512",
            Kex::DiffieGroup17Sha512 => "diffie-hellman-group17-sha512",
            Kex::DiffieGroup18Sha512 => "diffie-hellman-group18-sha512",
            Kex::EcdhSha2256 => "ecdh-sha2-nistp256",
            Kex::EcdhSha2384 => "ecdh-sha2-nistp384",
            Kex::EcdhSha2521 => "ecdh-sha2-nistp521",
            Kex::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "curve25519-sha256",
            "curve25519-sha256@libssh.org",
            "diffie-hellman-group-exchange-sha1",
            "diffie-hellman-group-exchange-sha256",
            "diffie-hellman-group1-sha1",
            "diffie-hellman-group14-sha1",
            "diffie-hellman-group14-sha256",
            "diffie-hellman-group15-sha512",
            "diffie-hellman-group16-sha512",
            "diffie-hellman-group17-sha512",
            "diffie-hellman-group18-sha512",
            "ecdh-sha2-nistp256",
            "ecdh-sha2-nistp384",
            "ecdh-sha2-nistp521",
        ]
    }
}
impl AsRef<str> for Kex {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `FtpIntervalUnit`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let ftpintervalunit = unimplemented!();
/// match ftpintervalunit {
///     FtpIntervalUnit::Hours => { /* ... */ },
///     FtpIntervalUnit::Minutes => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `ftpintervalunit` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `FtpIntervalUnit::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `FtpIntervalUnit::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `FtpIntervalUnit::NewFeature` is defined.
/// Specifically, when `ftpintervalunit` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `FtpIntervalUnit::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum FtpIntervalUnit {
    #[allow(missing_docs)] // documentation missing in model
    Hours,
    #[allow(missing_docs)] // documentation missing in model
    Minutes,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for FtpIntervalUnit {
    fn from(s: &str) -> Self {
        match s {
            "hours" => FtpIntervalUnit::Hours,
            "minutes" => FtpIntervalUnit::Minutes,
            other => FtpIntervalUnit::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for FtpIntervalUnit {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(FtpIntervalUnit::from(s))
    }
}
impl FtpIntervalUnit {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            FtpIntervalUnit::Hours => "hours",
            FtpIntervalUnit::Minutes => "minutes",
            FtpIntervalUnit::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["hours", "minutes"]
    }
}
impl AsRef<str> for FtpIntervalUnit {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `X12ControlNumberType`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let x12controlnumbertype = unimplemented!();
/// match x12controlnumbertype {
///     X12ControlNumberType::Group => { /* ... */ },
///     X12ControlNumberType::Interchange => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `x12controlnumbertype` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `X12ControlNumberType::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `X12ControlNumberType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `X12ControlNumberType::NewFeature` is defined.
/// Specifically, when `x12controlnumbertype` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `X12ControlNumberType::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum X12ControlNumberType {
    #[allow(missing_docs)] // documentation missing in model
    Group,
    #[allow(missing_docs)] // documentation missing in model
    Interchange,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for X12ControlNumberType {
    fn from(s: &str) -> Self {
        match s {
            "group" => X12ControlNumberType::Group,
            "interchange" => X12ControlNumberType::Interchange,
            other => {
                X12ControlNumberType::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
            }
        }
    }
}
impl std::str::FromStr for X12ControlNumberType {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(X12ControlNumberType::from(s))
    }
}
impl X12ControlNumberType {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            X12ControlNumberType::Group => "group",
            X12ControlNumberType::Interchange => "interchange",
            X12ControlNumberType::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["group", "interchange"]
    }
}
impl AsRef<str> for X12ControlNumberType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct As2ConnectionSummary {
    /// 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 created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
    /// 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 certificate_version: std::option::Option<crate::model::As2CertificateVersion>,
    /// Connection Status
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::StackStatus>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl As2ConnectionSummary {
    /// 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 created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.as_ref()
    }
    /// 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 certificate_version(&self) -> std::option::Option<&crate::model::As2CertificateVersion> {
        self.certificate_version.as_ref()
    }
    /// Connection Status
    pub fn status(&self) -> std::option::Option<&crate::model::StackStatus> {
        self.status.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}
/// See [`As2ConnectionSummary`](crate::model::As2ConnectionSummary).
pub mod as2_connection_summary {

    /// A builder for [`As2ConnectionSummary`](crate::model::As2ConnectionSummary).
    #[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) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) certificate_version: std::option::Option<crate::model::As2CertificateVersion>,
        pub(crate) status: std::option::Option<crate::model::StackStatus>,
        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 created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = 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 certificate_version(mut self, input: crate::model::As2CertificateVersion) -> Self {
            self.certificate_version = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_certificate_version(
            mut self,
            input: std::option::Option<crate::model::As2CertificateVersion>,
        ) -> Self {
            self.certificate_version = input;
            self
        }
        /// Connection Status
        pub fn status(mut self, input: crate::model::StackStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// Connection Status
        pub fn set_status(mut self, input: std::option::Option<crate::model::StackStatus>) -> Self {
            self.status = 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 [`As2ConnectionSummary`](crate::model::As2ConnectionSummary).
        pub fn build(self) -> crate::model::As2ConnectionSummary {
            crate::model::As2ConnectionSummary {
                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,
                created_at: self.created_at,
                updated_at: self.updated_at,
                connection_id: self.connection_id,
                certificate_version: self.certificate_version,
                status: self.status,
                enabled: self.enabled,
            }
        }
    }
}
impl As2ConnectionSummary {
    /// Creates a new builder-style object to manufacture [`As2ConnectionSummary`](crate::model::As2ConnectionSummary).
    pub fn builder() -> crate::model::as2_connection_summary::Builder {
        crate::model::as2_connection_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct As2CertificateVersion {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_signing: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub local_encryption: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_signing: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_encryption: std::option::Option<i32>,
}
impl As2CertificateVersion {
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_signing(&self) -> std::option::Option<i32> {
        self.local_signing
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn local_encryption(&self) -> std::option::Option<i32> {
        self.local_encryption
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_signing(&self) -> std::option::Option<i32> {
        self.partner_signing
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_encryption(&self) -> std::option::Option<i32> {
        self.partner_encryption
    }
}
/// See [`As2CertificateVersion`](crate::model::As2CertificateVersion).
pub mod as2_certificate_version {

    /// A builder for [`As2CertificateVersion`](crate::model::As2CertificateVersion).
    #[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<i32>,
        pub(crate) local_encryption: std::option::Option<i32>,
        pub(crate) partner_signing: std::option::Option<i32>,
        pub(crate) partner_encryption: std::option::Option<i32>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_signing(mut self, input: i32) -> 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<i32>) -> Self {
            self.local_signing = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn local_encryption(mut self, input: i32) -> 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<i32>) -> Self {
            self.local_encryption = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_signing(mut self, input: i32) -> 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<i32>) -> Self {
            self.partner_signing = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_encryption(mut self, input: i32) -> 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<i32>) -> Self {
            self.partner_encryption = input;
            self
        }
        /// Consumes the builder and constructs a [`As2CertificateVersion`](crate::model::As2CertificateVersion).
        pub fn build(self) -> crate::model::As2CertificateVersion {
            crate::model::As2CertificateVersion {
                local_signing: self.local_signing,
                local_encryption: self.local_encryption,
                partner_signing: self.partner_signing,
                partner_encryption: self.partner_encryption,
            }
        }
    }
}
impl As2CertificateVersion {
    /// Creates a new builder-style object to manufacture [`As2CertificateVersion`](crate::model::As2CertificateVersion).
    pub fn builder() -> crate::model::as2_certificate_version::Builder {
        crate::model::as2_certificate_version::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct As2OutboundFields {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: bool,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub partner_server_url: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub encryption_algorithm: std::option::Option<crate::model::OutboundEncryptionAlgorithm>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub mdn_response: std::option::Option<crate::model::MdnResponse>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub basic_auth: std::option::Option<crate::model::As2OutboundBasicAuth>,
}
impl As2OutboundFields {
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> bool {
        self.enabled
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn partner_server_url(&self) -> std::option::Option<&str> {
        self.partner_server_url.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn encryption_algorithm(
        &self,
    ) -> std::option::Option<&crate::model::OutboundEncryptionAlgorithm> {
        self.encryption_algorithm.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn mdn_response(&self) -> std::option::Option<&crate::model::MdnResponse> {
        self.mdn_response.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn basic_auth(&self) -> std::option::Option<&crate::model::As2OutboundBasicAuth> {
        self.basic_auth.as_ref()
    }
}
/// See [`As2OutboundFields`](crate::model::As2OutboundFields).
pub mod as2_outbound_fields {

    /// A builder for [`As2OutboundFields`](crate::model::As2OutboundFields).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) enabled: std::option::Option<bool>,
        pub(crate) partner_server_url: std::option::Option<std::string::String>,
        pub(crate) encryption_algorithm:
            std::option::Option<crate::model::OutboundEncryptionAlgorithm>,
        pub(crate) mdn_response: std::option::Option<crate::model::MdnResponse>,
        pub(crate) basic_auth: std::option::Option<crate::model::As2OutboundBasicAuth>,
    }
    impl Builder {
        #[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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn partner_server_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.partner_server_url = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_partner_server_url(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.partner_server_url = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn encryption_algorithm(
            mut self,
            input: crate::model::OutboundEncryptionAlgorithm,
        ) -> Self {
            self.encryption_algorithm = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_encryption_algorithm(
            mut self,
            input: std::option::Option<crate::model::OutboundEncryptionAlgorithm>,
        ) -> Self {
            self.encryption_algorithm = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn mdn_response(mut self, input: crate::model::MdnResponse) -> Self {
            self.mdn_response = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_mdn_response(
            mut self,
            input: std::option::Option<crate::model::MdnResponse>,
        ) -> Self {
            self.mdn_response = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn basic_auth(mut self, input: crate::model::As2OutboundBasicAuth) -> Self {
            self.basic_auth = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_basic_auth(
            mut self,
            input: std::option::Option<crate::model::As2OutboundBasicAuth>,
        ) -> Self {
            self.basic_auth = input;
            self
        }
        /// Consumes the builder and constructs a [`As2OutboundFields`](crate::model::As2OutboundFields).
        pub fn build(self) -> crate::model::As2OutboundFields {
            crate::model::As2OutboundFields {
                enabled: self.enabled.unwrap_or_default(),
                partner_server_url: self.partner_server_url,
                encryption_algorithm: self.encryption_algorithm,
                mdn_response: self.mdn_response,
                basic_auth: self.basic_auth,
            }
        }
    }
}
impl As2OutboundFields {
    /// Creates a new builder-style object to manufacture [`As2OutboundFields`](crate::model::As2OutboundFields).
    pub fn builder() -> crate::model::as2_outbound_fields::Builder {
        crate::model::as2_outbound_fields::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct As2OutboundBasicAuth {
    #[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>,
}
impl As2OutboundBasicAuth {
    #[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()
    }
}
/// See [`As2OutboundBasicAuth`](crate::model::As2OutboundBasicAuth).
pub mod as2_outbound_basic_auth {

    /// A builder for [`As2OutboundBasicAuth`](crate::model::As2OutboundBasicAuth).
    #[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>,
    }
    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
        }
        /// Consumes the builder and constructs a [`As2OutboundBasicAuth`](crate::model::As2OutboundBasicAuth).
        pub fn build(self) -> crate::model::As2OutboundBasicAuth {
            crate::model::As2OutboundBasicAuth {
                username: self.username,
                password: self.password,
            }
        }
    }
}
impl As2OutboundBasicAuth {
    /// Creates a new builder-style object to manufacture [`As2OutboundBasicAuth`](crate::model::As2OutboundBasicAuth).
    pub fn builder() -> crate::model::as2_outbound_basic_auth::Builder {
        crate::model::as2_outbound_basic_auth::Builder::default()
    }
}

/// When writing a match expression against `MdnResponse`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let mdnresponse = unimplemented!();
/// match mdnresponse {
///     MdnResponse::None => { /* ... */ },
///     MdnResponse::Sync => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `mdnresponse` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `MdnResponse::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `MdnResponse::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `MdnResponse::NewFeature` is defined.
/// Specifically, when `mdnresponse` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `MdnResponse::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum MdnResponse {
    #[allow(missing_docs)] // documentation missing in model
    None,
    #[allow(missing_docs)] // documentation missing in model
    Sync,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for MdnResponse {
    fn from(s: &str) -> Self {
        match s {
            "none" => MdnResponse::None,
            "sync" => MdnResponse::Sync,
            other => MdnResponse::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for MdnResponse {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(MdnResponse::from(s))
    }
}
impl MdnResponse {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            MdnResponse::None => "none",
            MdnResponse::Sync => "sync",
            MdnResponse::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["none", "sync"]
    }
}
impl AsRef<str> for MdnResponse {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `OutboundEncryptionAlgorithm`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let outboundencryptionalgorithm = unimplemented!();
/// match outboundencryptionalgorithm {
///     OutboundEncryptionAlgorithm::Aes128Cbc => { /* ... */ },
///     OutboundEncryptionAlgorithm::Aes192Cbc => { /* ... */ },
///     OutboundEncryptionAlgorithm::Aes256Cbc => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `outboundencryptionalgorithm` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `OutboundEncryptionAlgorithm::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `OutboundEncryptionAlgorithm::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `OutboundEncryptionAlgorithm::NewFeature` is defined.
/// Specifically, when `outboundencryptionalgorithm` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `OutboundEncryptionAlgorithm::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum OutboundEncryptionAlgorithm {
    #[allow(missing_docs)] // documentation missing in model
    Aes128Cbc,
    #[allow(missing_docs)] // documentation missing in model
    Aes192Cbc,
    #[allow(missing_docs)] // documentation missing in model
    Aes256Cbc,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for OutboundEncryptionAlgorithm {
    fn from(s: &str) -> Self {
        match s {
            "aes128_cbc" => OutboundEncryptionAlgorithm::Aes128Cbc,
            "aes192_cbc" => OutboundEncryptionAlgorithm::Aes192Cbc,
            "aes256_cbc" => OutboundEncryptionAlgorithm::Aes256Cbc,
            other => OutboundEncryptionAlgorithm::Unknown(crate::types::UnknownVariantValue(
                other.to_owned(),
            )),
        }
    }
}
impl std::str::FromStr for OutboundEncryptionAlgorithm {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(OutboundEncryptionAlgorithm::from(s))
    }
}
impl OutboundEncryptionAlgorithm {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            OutboundEncryptionAlgorithm::Aes128Cbc => "aes128_cbc",
            OutboundEncryptionAlgorithm::Aes192Cbc => "aes192_cbc",
            OutboundEncryptionAlgorithm::Aes256Cbc => "aes256_cbc",
            OutboundEncryptionAlgorithm::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["aes128_cbc", "aes192_cbc", "aes256_cbc"]
    }
}
impl AsRef<str> for OutboundEncryptionAlgorithm {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct As2InboundFields {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: bool,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub encryption_algorithm: std::option::Option<crate::model::InboundEncryptionAlgorithm>,
}
impl As2InboundFields {
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> bool {
        self.enabled
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn encryption_algorithm(
        &self,
    ) -> std::option::Option<&crate::model::InboundEncryptionAlgorithm> {
        self.encryption_algorithm.as_ref()
    }
}
/// See [`As2InboundFields`](crate::model::As2InboundFields).
pub mod as2_inbound_fields {

    /// A builder for [`As2InboundFields`](crate::model::As2InboundFields).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) enabled: std::option::Option<bool>,
        pub(crate) encryption_algorithm:
            std::option::Option<crate::model::InboundEncryptionAlgorithm>,
    }
    impl Builder {
        #[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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn encryption_algorithm(
            mut self,
            input: crate::model::InboundEncryptionAlgorithm,
        ) -> Self {
            self.encryption_algorithm = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_encryption_algorithm(
            mut self,
            input: std::option::Option<crate::model::InboundEncryptionAlgorithm>,
        ) -> Self {
            self.encryption_algorithm = input;
            self
        }
        /// Consumes the builder and constructs a [`As2InboundFields`](crate::model::As2InboundFields).
        pub fn build(self) -> crate::model::As2InboundFields {
            crate::model::As2InboundFields {
                enabled: self.enabled.unwrap_or_default(),
                encryption_algorithm: self.encryption_algorithm,
            }
        }
    }
}
impl As2InboundFields {
    /// Creates a new builder-style object to manufacture [`As2InboundFields`](crate::model::As2InboundFields).
    pub fn builder() -> crate::model::as2_inbound_fields::Builder {
        crate::model::as2_inbound_fields::Builder::default()
    }
}

/// When writing a match expression against `InboundEncryptionAlgorithm`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let inboundencryptionalgorithm = unimplemented!();
/// match inboundencryptionalgorithm {
///     InboundEncryptionAlgorithm::TripleDes => { /* ... */ },
///     InboundEncryptionAlgorithm::Aes128Cbc => { /* ... */ },
///     InboundEncryptionAlgorithm::Aes192Cbc => { /* ... */ },
///     InboundEncryptionAlgorithm::Aes256Cbc => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `inboundencryptionalgorithm` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `InboundEncryptionAlgorithm::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `InboundEncryptionAlgorithm::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `InboundEncryptionAlgorithm::NewFeature` is defined.
/// Specifically, when `inboundencryptionalgorithm` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `InboundEncryptionAlgorithm::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum InboundEncryptionAlgorithm {
    #[allow(missing_docs)] // documentation missing in model
    TripleDes,
    #[allow(missing_docs)] // documentation missing in model
    Aes128Cbc,
    #[allow(missing_docs)] // documentation missing in model
    Aes192Cbc,
    #[allow(missing_docs)] // documentation missing in model
    Aes256Cbc,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for InboundEncryptionAlgorithm {
    fn from(s: &str) -> Self {
        match s {
            "3des" => InboundEncryptionAlgorithm::TripleDes,
            "aes128_cbc" => InboundEncryptionAlgorithm::Aes128Cbc,
            "aes192_cbc" => InboundEncryptionAlgorithm::Aes192Cbc,
            "aes256_cbc" => InboundEncryptionAlgorithm::Aes256Cbc,
            other => InboundEncryptionAlgorithm::Unknown(crate::types::UnknownVariantValue(
                other.to_owned(),
            )),
        }
    }
}
impl std::str::FromStr for InboundEncryptionAlgorithm {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(InboundEncryptionAlgorithm::from(s))
    }
}
impl InboundEncryptionAlgorithm {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            InboundEncryptionAlgorithm::TripleDes => "3des",
            InboundEncryptionAlgorithm::Aes128Cbc => "aes128_cbc",
            InboundEncryptionAlgorithm::Aes192Cbc => "aes192_cbc",
            InboundEncryptionAlgorithm::Aes256Cbc => "aes256_cbc",
            InboundEncryptionAlgorithm::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["3des", "aes128_cbc", "aes192_cbc", "aes256_cbc"]
    }
}
impl AsRef<str> for InboundEncryptionAlgorithm {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RemoteFtpConnectionSummary {
    /// 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    /// Connection Status
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::StackStatus>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl RemoteFtpConnectionSummary {
    /// 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()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.as_ref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    /// Connection Status
    pub fn status(&self) -> std::option::Option<&crate::model::StackStatus> {
        self.status.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}
/// See [`RemoteFtpConnectionSummary`](crate::model::RemoteFtpConnectionSummary).
pub mod remote_ftp_connection_summary {

    /// A builder for [`RemoteFtpConnectionSummary`](crate::model::RemoteFtpConnectionSummary).
    #[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) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) status: std::option::Option<crate::model::StackStatus>,
        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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = 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
        }
        /// Connection Status
        pub fn status(mut self, input: crate::model::StackStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// Connection Status
        pub fn set_status(mut self, input: std::option::Option<crate::model::StackStatus>) -> Self {
            self.status = 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 [`RemoteFtpConnectionSummary`](crate::model::RemoteFtpConnectionSummary).
        pub fn build(self) -> crate::model::RemoteFtpConnectionSummary {
            crate::model::RemoteFtpConnectionSummary {
                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,
                created_at: self.created_at,
                updated_at: self.updated_at,
                connection_id: self.connection_id,
                status: self.status,
                enabled: self.enabled,
            }
        }
    }
}
impl RemoteFtpConnectionSummary {
    /// Creates a new builder-style object to manufacture [`RemoteFtpConnectionSummary`](crate::model::RemoteFtpConnectionSummary).
    pub fn builder() -> crate::model::remote_ftp_connection_summary::Builder {
        crate::model::remote_ftp_connection_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StediFtpConnectionFields {
    /// 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: 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 created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    /// Connection Status
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::StackStatus>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl StediFtpConnectionFields {
    /// 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) -> 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 created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.as_ref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    /// Connection Status
    pub fn status(&self) -> std::option::Option<&crate::model::StackStatus> {
        self.status.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}
/// See [`StediFtpConnectionFields`](crate::model::StediFtpConnectionFields).
pub mod stedi_ftp_connection_fields {

    /// A builder for [`StediFtpConnectionFields`](crate::model::StediFtpConnectionFields).
    #[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) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) status: std::option::Option<crate::model::StackStatus>,
        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
        }
        /// 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 created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = 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
        }
        /// Connection Status
        pub fn status(mut self, input: crate::model::StackStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// Connection Status
        pub fn set_status(mut self, input: std::option::Option<crate::model::StackStatus>) -> Self {
            self.status = 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 [`StediFtpConnectionFields`](crate::model::StediFtpConnectionFields).
        pub fn build(self) -> crate::model::StediFtpConnectionFields {
            crate::model::StediFtpConnectionFields {
                name: self.name,
                inbound_subdirectory: self.inbound_subdirectory,
                outbound_subdirectory: self.outbound_subdirectory,
                delete_inbound_files_on_receipt: self
                    .delete_inbound_files_on_receipt
                    .unwrap_or_default(),
                username: self.username,
                bucket_name: self.bucket_name,
                home_directory: self.home_directory,
                created_at: self.created_at,
                updated_at: self.updated_at,
                connection_id: self.connection_id,
                status: self.status,
                enabled: self.enabled,
            }
        }
    }
}
impl StediFtpConnectionFields {
    /// Creates a new builder-style object to manufacture [`StediFtpConnectionFields`](crate::model::StediFtpConnectionFields).
    pub fn builder() -> crate::model::stedi_ftp_connection_fields::Builder {
        crate::model::stedi_ftp_connection_fields::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BucketConnectionFields {
    /// 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: 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 created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    /// Connection Status
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::StackStatus>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl BucketConnectionFields {
    /// 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) -> 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 created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.as_ref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    /// Connection Status
    pub fn status(&self) -> std::option::Option<&crate::model::StackStatus> {
        self.status.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}
/// See [`BucketConnectionFields`](crate::model::BucketConnectionFields).
pub mod bucket_connection_fields {

    /// A builder for [`BucketConnectionFields`](crate::model::BucketConnectionFields).
    #[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) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) status: std::option::Option<crate::model::StackStatus>,
        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
        }
        /// 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 created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = 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
        }
        /// Connection Status
        pub fn status(mut self, input: crate::model::StackStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// Connection Status
        pub fn set_status(mut self, input: std::option::Option<crate::model::StackStatus>) -> Self {
            self.status = 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 [`BucketConnectionFields`](crate::model::BucketConnectionFields).
        pub fn build(self) -> crate::model::BucketConnectionFields {
            crate::model::BucketConnectionFields {
                name: self.name,
                inbound_subdirectory: self.inbound_subdirectory,
                outbound_subdirectory: self.outbound_subdirectory,
                delete_inbound_files_on_receipt: self
                    .delete_inbound_files_on_receipt
                    .unwrap_or_default(),
                bucket_name: self.bucket_name,
                parent_directory: self.parent_directory,
                created_at: self.created_at,
                updated_at: self.updated_at,
                connection_id: self.connection_id,
                status: self.status,
                enabled: self.enabled,
            }
        }
    }
}
impl BucketConnectionFields {
    /// Creates a new builder-style object to manufacture [`BucketConnectionFields`](crate::model::BucketConnectionFields).
    pub fn builder() -> crate::model::bucket_connection_fields::Builder {
        crate::model::bucket_connection_fields::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct As2PartnerCertificate {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub remove: bool,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub public_certificate: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub certificate_chain: std::option::Option<std::string::String>,
}
impl As2PartnerCertificate {
    #[allow(missing_docs)] // documentation missing in model
    pub fn remove(&self) -> bool {
        self.remove
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn public_certificate(&self) -> std::option::Option<&str> {
        self.public_certificate.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn certificate_chain(&self) -> std::option::Option<&str> {
        self.certificate_chain.as_deref()
    }
}
/// See [`As2PartnerCertificate`](crate::model::As2PartnerCertificate).
pub mod as2_partner_certificate {

    /// A builder for [`As2PartnerCertificate`](crate::model::As2PartnerCertificate).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) remove: std::option::Option<bool>,
        pub(crate) public_certificate: std::option::Option<std::string::String>,
        pub(crate) certificate_chain: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn remove(mut self, input: bool) -> Self {
            self.remove = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_remove(mut self, input: std::option::Option<bool>) -> Self {
            self.remove = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn public_certificate(mut self, input: impl Into<std::string::String>) -> Self {
            self.public_certificate = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_public_certificate(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.public_certificate = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn certificate_chain(mut self, input: impl Into<std::string::String>) -> Self {
            self.certificate_chain = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_certificate_chain(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.certificate_chain = input;
            self
        }
        /// Consumes the builder and constructs a [`As2PartnerCertificate`](crate::model::As2PartnerCertificate).
        pub fn build(self) -> crate::model::As2PartnerCertificate {
            crate::model::As2PartnerCertificate {
                remove: self.remove.unwrap_or_default(),
                public_certificate: self.public_certificate,
                certificate_chain: self.certificate_chain,
            }
        }
    }
}
impl As2PartnerCertificate {
    /// Creates a new builder-style object to manufacture [`As2PartnerCertificate`](crate::model::As2PartnerCertificate).
    pub fn builder() -> crate::model::as2_partner_certificate::Builder {
        crate::model::as2_partner_certificate::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct As2LocalCertificate {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub remove: bool,
    #[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 public_certificate: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub certificate_chain: std::option::Option<std::string::String>,
}
impl As2LocalCertificate {
    #[allow(missing_docs)] // documentation missing in model
    pub fn remove(&self) -> bool {
        self.remove
    }
    #[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 public_certificate(&self) -> std::option::Option<&str> {
        self.public_certificate.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn certificate_chain(&self) -> std::option::Option<&str> {
        self.certificate_chain.as_deref()
    }
}
/// See [`As2LocalCertificate`](crate::model::As2LocalCertificate).
pub mod as2_local_certificate {

    /// A builder for [`As2LocalCertificate`](crate::model::As2LocalCertificate).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) remove: std::option::Option<bool>,
        pub(crate) private_key: std::option::Option<std::string::String>,
        pub(crate) public_certificate: std::option::Option<std::string::String>,
        pub(crate) certificate_chain: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn remove(mut self, input: bool) -> Self {
            self.remove = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_remove(mut self, input: std::option::Option<bool>) -> Self {
            self.remove = 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 public_certificate(mut self, input: impl Into<std::string::String>) -> Self {
            self.public_certificate = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_public_certificate(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.public_certificate = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn certificate_chain(mut self, input: impl Into<std::string::String>) -> Self {
            self.certificate_chain = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_certificate_chain(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.certificate_chain = input;
            self
        }
        /// Consumes the builder and constructs a [`As2LocalCertificate`](crate::model::As2LocalCertificate).
        pub fn build(self) -> crate::model::As2LocalCertificate {
            crate::model::As2LocalCertificate {
                remove: self.remove.unwrap_or_default(),
                private_key: self.private_key,
                public_certificate: self.public_certificate,
                certificate_chain: self.certificate_chain,
            }
        }
    }
}
impl As2LocalCertificate {
    /// Creates a new builder-style object to manufacture [`As2LocalCertificate`](crate::model::As2LocalCertificate).
    pub fn builder() -> crate::model::as2_local_certificate::Builder {
        crate::model::as2_local_certificate::Builder::default()
    }
}

/// 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 GlobalConnectionSummary {
    /// 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub created_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub updated_at: std::option::Option<aws_smithy_types::DateTime>,
    /// Autogenerated identifier for a connection
    #[doc(hidden)]
    pub connection_id: std::option::Option<std::string::String>,
    /// Connection Status
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::StackStatus>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub enabled: std::option::Option<bool>,
}
impl GlobalConnectionSummary {
    /// 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
    pub fn created_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn updated_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.updated_at.as_ref()
    }
    /// Autogenerated identifier for a connection
    pub fn connection_id(&self) -> std::option::Option<&str> {
        self.connection_id.as_deref()
    }
    /// Connection Status
    pub fn status(&self) -> std::option::Option<&crate::model::StackStatus> {
        self.status.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn enabled(&self) -> std::option::Option<bool> {
        self.enabled
    }
}
/// See [`GlobalConnectionSummary`](crate::model::GlobalConnectionSummary).
pub mod global_connection_summary {

    /// A builder for [`GlobalConnectionSummary`](crate::model::GlobalConnectionSummary).
    #[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>,
        pub(crate) created_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) updated_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) connection_id: std::option::Option<std::string::String>,
        pub(crate) status: std::option::Option<crate::model::StackStatus>,
        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
        }
        /// 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 created_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_created_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn updated_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.updated_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_updated_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.updated_at = 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
        }
        /// Connection Status
        pub fn status(mut self, input: crate::model::StackStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// Connection Status
        pub fn set_status(mut self, input: std::option::Option<crate::model::StackStatus>) -> Self {
            self.status = 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 [`GlobalConnectionSummary`](crate::model::GlobalConnectionSummary).
        pub fn build(self) -> crate::model::GlobalConnectionSummary {
            crate::model::GlobalConnectionSummary {
                name: self.name,
                bucket_name: self.bucket_name,
                created_at: self.created_at,
                updated_at: self.updated_at,
                connection_id: self.connection_id,
                status: self.status,
                enabled: self.enabled,
            }
        }
    }
}
impl GlobalConnectionSummary {
    /// Creates a new builder-style object to manufacture [`GlobalConnectionSummary`](crate::model::GlobalConnectionSummary).
    pub fn builder() -> crate::model::global_connection_summary::Builder {
        crate::model::global_connection_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct X12InterchangeIdentifier {
    #[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>,
}
impl X12InterchangeIdentifier {
    #[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()
    }
}
/// See [`X12InterchangeIdentifier`](crate::model::X12InterchangeIdentifier).
pub mod x12_interchange_identifier {

    /// A builder for [`X12InterchangeIdentifier`](crate::model::X12InterchangeIdentifier).
    #[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>,
    }
    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
        }
        /// Consumes the builder and constructs a [`X12InterchangeIdentifier`](crate::model::X12InterchangeIdentifier).
        pub fn build(self) -> crate::model::X12InterchangeIdentifier {
            crate::model::X12InterchangeIdentifier {
                interchange_qualifier: self.interchange_qualifier,
                interchange_id: self.interchange_id,
            }
        }
    }
}
impl X12InterchangeIdentifier {
    /// Creates a new builder-style object to manufacture [`X12InterchangeIdentifier`](crate::model::X12InterchangeIdentifier).
    pub fn builder() -> crate::model::x12_interchange_identifier::Builder {
        crate::model::x12_interchange_identifier::Builder::default()
    }
}

/// A validation error found when processing JSON data.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct JsonError {
    /// A code value representing the type of error.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
    /// The location in the JSON document where the error occurred.
    #[doc(hidden)]
    pub path: std::option::Option<std::vec::Vec<std::string::String>>,
    /// A description of the error encountered.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
}
impl JsonError {
    /// A code value representing the type of error.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
    /// The location in the JSON document where the error occurred.
    pub fn path(&self) -> std::option::Option<&[std::string::String]> {
        self.path.as_deref()
    }
    /// A description of the error encountered.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
/// See [`JsonError`](crate::model::JsonError).
pub mod json_error {

    /// A builder for [`JsonError`](crate::model::JsonError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) code: std::option::Option<std::string::String>,
        pub(crate) path: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// A code value representing the type of error.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// A code value representing the type of error.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Appends an item to `path`.
        ///
        /// To override the contents of this collection use [`set_path`](Self::set_path).
        ///
        /// The location in the JSON document where the error occurred.
        pub fn path(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.path.unwrap_or_default();
            v.push(input.into());
            self.path = Some(v);
            self
        }
        /// The location in the JSON document where the error occurred.
        pub fn set_path(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.path = input;
            self
        }
        /// A description of the error encountered.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// A description of the error encountered.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`JsonError`](crate::model::JsonError).
        pub fn build(self) -> crate::model::JsonError {
            crate::model::JsonError {
                code: self.code,
                path: self.path,
                message: self.message,
            }
        }
    }
}
impl JsonError {
    /// Creates a new builder-style object to manufacture [`JsonError`](crate::model::JsonError).
    pub fn builder() -> crate::model::json_error::Builder {
        crate::model::json_error::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct X12InterchangeAuthorization {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub authorization_information_qualifier:
        std::option::Option<crate::model::X12AuthorizationInformationQualifier>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub authorization_information: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub security_information_qualifier:
        std::option::Option<crate::model::X12SecurityInformationQualifier>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub security_information: std::option::Option<std::string::String>,
}
impl X12InterchangeAuthorization {
    #[allow(missing_docs)] // documentation missing in model
    pub fn authorization_information_qualifier(
        &self,
    ) -> std::option::Option<&crate::model::X12AuthorizationInformationQualifier> {
        self.authorization_information_qualifier.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn authorization_information(&self) -> std::option::Option<&str> {
        self.authorization_information.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn security_information_qualifier(
        &self,
    ) -> std::option::Option<&crate::model::X12SecurityInformationQualifier> {
        self.security_information_qualifier.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn security_information(&self) -> std::option::Option<&str> {
        self.security_information.as_deref()
    }
}
/// See [`X12InterchangeAuthorization`](crate::model::X12InterchangeAuthorization).
pub mod x12_interchange_authorization {

    /// A builder for [`X12InterchangeAuthorization`](crate::model::X12InterchangeAuthorization).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) authorization_information_qualifier:
            std::option::Option<crate::model::X12AuthorizationInformationQualifier>,
        pub(crate) authorization_information: std::option::Option<std::string::String>,
        pub(crate) security_information_qualifier:
            std::option::Option<crate::model::X12SecurityInformationQualifier>,
        pub(crate) security_information: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn authorization_information_qualifier(
            mut self,
            input: crate::model::X12AuthorizationInformationQualifier,
        ) -> Self {
            self.authorization_information_qualifier = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_authorization_information_qualifier(
            mut self,
            input: std::option::Option<crate::model::X12AuthorizationInformationQualifier>,
        ) -> Self {
            self.authorization_information_qualifier = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn authorization_information(mut self, input: impl Into<std::string::String>) -> Self {
            self.authorization_information = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_authorization_information(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.authorization_information = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn security_information_qualifier(
            mut self,
            input: crate::model::X12SecurityInformationQualifier,
        ) -> Self {
            self.security_information_qualifier = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_security_information_qualifier(
            mut self,
            input: std::option::Option<crate::model::X12SecurityInformationQualifier>,
        ) -> Self {
            self.security_information_qualifier = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn security_information(mut self, input: impl Into<std::string::String>) -> Self {
            self.security_information = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_security_information(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.security_information = input;
            self
        }
        /// Consumes the builder and constructs a [`X12InterchangeAuthorization`](crate::model::X12InterchangeAuthorization).
        pub fn build(self) -> crate::model::X12InterchangeAuthorization {
            crate::model::X12InterchangeAuthorization {
                authorization_information_qualifier: self.authorization_information_qualifier,
                authorization_information: self.authorization_information,
                security_information_qualifier: self.security_information_qualifier,
                security_information: self.security_information,
            }
        }
    }
}
impl X12InterchangeAuthorization {
    /// Creates a new builder-style object to manufacture [`X12InterchangeAuthorization`](crate::model::X12InterchangeAuthorization).
    pub fn builder() -> crate::model::x12_interchange_authorization::Builder {
        crate::model::x12_interchange_authorization::Builder::default()
    }
}

/// When writing a match expression against `X12SecurityInformationQualifier`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let x12securityinformationqualifier = unimplemented!();
/// match x12securityinformationqualifier {
///     X12SecurityInformationQualifier::Code00 => { /* ... */ },
///     X12SecurityInformationQualifier::Code01 => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `x12securityinformationqualifier` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `X12SecurityInformationQualifier::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `X12SecurityInformationQualifier::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `X12SecurityInformationQualifier::NewFeature` is defined.
/// Specifically, when `x12securityinformationqualifier` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `X12SecurityInformationQualifier::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum X12SecurityInformationQualifier {
    /// No Security Information Present (No Meaningful Information in I04)
    Code00,
    /// Password
    Code01,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for X12SecurityInformationQualifier {
    fn from(s: &str) -> Self {
        match s {
            "00" => X12SecurityInformationQualifier::Code00,
            "01" => X12SecurityInformationQualifier::Code01,
            other => X12SecurityInformationQualifier::Unknown(crate::types::UnknownVariantValue(
                other.to_owned(),
            )),
        }
    }
}
impl std::str::FromStr for X12SecurityInformationQualifier {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(X12SecurityInformationQualifier::from(s))
    }
}
impl X12SecurityInformationQualifier {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            X12SecurityInformationQualifier::Code00 => "00",
            X12SecurityInformationQualifier::Code01 => "01",
            X12SecurityInformationQualifier::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["00", "01"]
    }
}
impl AsRef<str> for X12SecurityInformationQualifier {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `X12AuthorizationInformationQualifier`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let x12authorizationinformationqualifier = unimplemented!();
/// match x12authorizationinformationqualifier {
///     X12AuthorizationInformationQualifier::Code00 => { /* ... */ },
///     X12AuthorizationInformationQualifier::Code01 => { /* ... */ },
///     X12AuthorizationInformationQualifier::Code02 => { /* ... */ },
///     X12AuthorizationInformationQualifier::Code03 => { /* ... */ },
///     X12AuthorizationInformationQualifier::Code04 => { /* ... */ },
///     X12AuthorizationInformationQualifier::Code05 => { /* ... */ },
///     X12AuthorizationInformationQualifier::Code06 => { /* ... */ },
///     X12AuthorizationInformationQualifier::Code07 => { /* ... */ },
///     X12AuthorizationInformationQualifier::Code08 => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `x12authorizationinformationqualifier` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `X12AuthorizationInformationQualifier::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `X12AuthorizationInformationQualifier::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `X12AuthorizationInformationQualifier::NewFeature` is defined.
/// Specifically, when `x12authorizationinformationqualifier` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `X12AuthorizationInformationQualifier::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum X12AuthorizationInformationQualifier {
    /// No Authorization Information Present (No Meaningful Information in I02)
    Code00,
    /// UCS Communications ID
    Code01,
    /// EDX Communications ID
    Code02,
    /// Additional Data Identification
    Code03,
    /// Rail Communications ID
    Code04,
    /// Department of Defense (DoD) Communication Identifier
    Code05,
    /// United States Federal Government Communication Identifier
    Code06,
    /// Truck Communications ID
    Code07,
    /// Ocean Communications ID
    Code08,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for X12AuthorizationInformationQualifier {
    fn from(s: &str) -> Self {
        match s {
            "00" => X12AuthorizationInformationQualifier::Code00,
            "01" => X12AuthorizationInformationQualifier::Code01,
            "02" => X12AuthorizationInformationQualifier::Code02,
            "03" => X12AuthorizationInformationQualifier::Code03,
            "04" => X12AuthorizationInformationQualifier::Code04,
            "05" => X12AuthorizationInformationQualifier::Code05,
            "06" => X12AuthorizationInformationQualifier::Code06,
            "07" => X12AuthorizationInformationQualifier::Code07,
            "08" => X12AuthorizationInformationQualifier::Code08,
            other => X12AuthorizationInformationQualifier::Unknown(
                crate::types::UnknownVariantValue(other.to_owned()),
            ),
        }
    }
}
impl std::str::FromStr for X12AuthorizationInformationQualifier {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(X12AuthorizationInformationQualifier::from(s))
    }
}
impl X12AuthorizationInformationQualifier {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            X12AuthorizationInformationQualifier::Code00 => "00",
            X12AuthorizationInformationQualifier::Code01 => "01",
            X12AuthorizationInformationQualifier::Code02 => "02",
            X12AuthorizationInformationQualifier::Code03 => "03",
            X12AuthorizationInformationQualifier::Code04 => "04",
            X12AuthorizationInformationQualifier::Code05 => "05",
            X12AuthorizationInformationQualifier::Code06 => "06",
            X12AuthorizationInformationQualifier::Code07 => "07",
            X12AuthorizationInformationQualifier::Code08 => "08",
            X12AuthorizationInformationQualifier::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["00", "01", "02", "03", "04", "05", "06", "07", "08"]
    }
}
impl AsRef<str> for X12AuthorizationInformationQualifier {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TransactionGroup {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub transaction_setting_id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub transactions: std::option::Option<std::vec::Vec<aws_smithy_types::Document>>,
}
impl TransactionGroup {
    #[allow(missing_docs)] // documentation missing in model
    pub fn transaction_setting_id(&self) -> std::option::Option<&str> {
        self.transaction_setting_id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn transactions(&self) -> std::option::Option<&[aws_smithy_types::Document]> {
        self.transactions.as_deref()
    }
}
/// See [`TransactionGroup`](crate::model::TransactionGroup).
pub mod transaction_group {

    /// A builder for [`TransactionGroup`](crate::model::TransactionGroup).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) transaction_setting_id: std::option::Option<std::string::String>,
        pub(crate) transactions: std::option::Option<std::vec::Vec<aws_smithy_types::Document>>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn transaction_setting_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.transaction_setting_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_transaction_setting_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.transaction_setting_id = input;
            self
        }
        /// Appends an item to `transactions`.
        ///
        /// To override the contents of this collection use [`set_transactions`](Self::set_transactions).
        ///
        pub fn transactions(mut self, input: aws_smithy_types::Document) -> Self {
            let mut v = self.transactions.unwrap_or_default();
            v.push(input);
            self.transactions = Some(v);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_transactions(
            mut self,
            input: std::option::Option<std::vec::Vec<aws_smithy_types::Document>>,
        ) -> Self {
            self.transactions = input;
            self
        }
        /// Consumes the builder and constructs a [`TransactionGroup`](crate::model::TransactionGroup).
        pub fn build(self) -> crate::model::TransactionGroup {
            crate::model::TransactionGroup {
                transaction_setting_id: self.transaction_setting_id,
                transactions: self.transactions,
            }
        }
    }
}
impl TransactionGroup {
    /// Creates a new builder-style object to manufacture [`TransactionGroup`](crate::model::TransactionGroup).
    pub fn builder() -> crate::model::transaction_group::Builder {
        crate::model::transaction_group::Builder::default()
    }
}
