// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// When writing a match expression against `RequestTooLargeCode`, 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 requesttoolargecode = unimplemented!();
/// match requesttoolargecode {
///     RequestTooLargeCode::RequestTooLarge => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `requesttoolargecode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `RequestTooLargeCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `RequestTooLargeCode::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 `RequestTooLargeCode::NewFeature` is defined.
/// Specifically, when `requesttoolargecode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `RequestTooLargeCode::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 RequestTooLargeCode {
    #[allow(missing_docs)] // documentation missing in model
    RequestTooLarge,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for RequestTooLargeCode {
    fn from(s: &str) -> Self {
        match s {
            "requestTooLarge" => RequestTooLargeCode::RequestTooLarge,
            other => {
                RequestTooLargeCode::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
            }
        }
    }
}
impl std::str::FromStr for RequestTooLargeCode {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(RequestTooLargeCode::from(s))
    }
}
impl RequestTooLargeCode {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            RequestTooLargeCode::RequestTooLarge => "requestTooLarge",
            RequestTooLargeCode::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["requestTooLarge"]
    }
}
impl AsRef<str> for RequestTooLargeCode {
    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 NotFoundData {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub property: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub identifier: std::option::Option<std::string::String>,
}
impl NotFoundData {
    #[allow(missing_docs)] // documentation missing in model
    pub fn property(&self) -> std::option::Option<&str> {
        self.property.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn identifier(&self) -> std::option::Option<&str> {
        self.identifier.as_deref()
    }
}
/// See [`NotFoundData`](crate::model::NotFoundData).
pub mod not_found_data {

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

/// When writing a match expression against `NotFoundCode`, 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 notfoundcode = unimplemented!();
/// match notfoundcode {
///     NotFoundCode::NotFound => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `notfoundcode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `NotFoundCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `NotFoundCode::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 `NotFoundCode::NewFeature` is defined.
/// Specifically, when `notfoundcode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `NotFoundCode::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 NotFoundCode {
    #[allow(missing_docs)] // documentation missing in model
    NotFound,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for NotFoundCode {
    fn from(s: &str) -> Self {
        match s {
            "notFound" => NotFoundCode::NotFound,
            other => NotFoundCode::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for NotFoundCode {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(NotFoundCode::from(s))
    }
}
impl NotFoundCode {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            NotFoundCode::NotFound => "notFound",
            NotFoundCode::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["notFound"]
    }
}
impl AsRef<str> for NotFoundCode {
    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 FieldListItem {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub path: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
}
impl FieldListItem {
    #[allow(missing_docs)] // documentation missing in model
    pub fn path(&self) -> std::option::Option<&str> {
        self.path.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
/// See [`FieldListItem`](crate::model::FieldListItem).
pub mod field_list_item {

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

/// When writing a match expression against `BadRequestCode`, 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 badrequestcode = unimplemented!();
/// match badrequestcode {
///     BadRequestCode::BadRequest => { /* ... */ },
///     BadRequestCode::InvalidJson => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `badrequestcode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `BadRequestCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `BadRequestCode::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 `BadRequestCode::NewFeature` is defined.
/// Specifically, when `badrequestcode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `BadRequestCode::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 BadRequestCode {
    #[allow(missing_docs)] // documentation missing in model
    BadRequest,
    #[allow(missing_docs)] // documentation missing in model
    InvalidJson,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for BadRequestCode {
    fn from(s: &str) -> Self {
        match s {
            "badRequest" => BadRequestCode::BadRequest,
            "invalidJSON" => BadRequestCode::InvalidJson,
            other => BadRequestCode::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for BadRequestCode {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(BadRequestCode::from(s))
    }
}
impl BadRequestCode {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            BadRequestCode::BadRequest => "badRequest",
            BadRequestCode::InvalidJson => "invalidJSON",
            BadRequestCode::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["badRequest", "invalidJSON"]
    }
}
impl AsRef<str> for BadRequestCode {
    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 ConflictData {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub property: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub value: std::option::Option<std::string::String>,
}
impl ConflictData {
    #[allow(missing_docs)] // documentation missing in model
    pub fn property(&self) -> std::option::Option<&str> {
        self.property.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn value(&self) -> std::option::Option<&str> {
        self.value.as_deref()
    }
}
/// See [`ConflictData`](crate::model::ConflictData).
pub mod conflict_data {

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

/// When writing a match expression against `ConflictCode`, 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 conflictcode = unimplemented!();
/// match conflictcode {
///     ConflictCode::Conflict => { /* ... */ },
///     ConflictCode::UpdateInProgress => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `conflictcode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `ConflictCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `ConflictCode::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 `ConflictCode::NewFeature` is defined.
/// Specifically, when `conflictcode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `ConflictCode::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 ConflictCode {
    #[allow(missing_docs)] // documentation missing in model
    Conflict,
    #[allow(missing_docs)] // documentation missing in model
    UpdateInProgress,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ConflictCode {
    fn from(s: &str) -> Self {
        match s {
            "conflict" => ConflictCode::Conflict,
            "updateInProgress" => ConflictCode::UpdateInProgress,
            other => ConflictCode::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for ConflictCode {
    type Err = std::convert::Infallible;

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

/// When writing a match expression against `UnauthorizedCode`, 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 unauthorizedcode = unimplemented!();
/// match unauthorizedcode {
///     UnauthorizedCode::CredentialValidationFailed => { /* ... */ },
///     UnauthorizedCode::Unauthorized => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `unauthorizedcode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `UnauthorizedCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `UnauthorizedCode::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 `UnauthorizedCode::NewFeature` is defined.
/// Specifically, when `unauthorizedcode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `UnauthorizedCode::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 UnauthorizedCode {
    #[allow(missing_docs)] // documentation missing in model
    CredentialValidationFailed,
    #[allow(missing_docs)] // documentation missing in model
    Unauthorized,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for UnauthorizedCode {
    fn from(s: &str) -> Self {
        match s {
            "credentialValidationFailed" => UnauthorizedCode::CredentialValidationFailed,
            "unauthorized" => UnauthorizedCode::Unauthorized,
            other => UnauthorizedCode::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for UnauthorizedCode {
    type Err = std::convert::Infallible;

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

/// When writing a match expression against `AccessDeniedCode`, 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 accessdeniedcode = unimplemented!();
/// match accessdeniedcode {
///     AccessDeniedCode::AccessDenied => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `accessdeniedcode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `AccessDeniedCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `AccessDeniedCode::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 `AccessDeniedCode::NewFeature` is defined.
/// Specifically, when `accessdeniedcode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `AccessDeniedCode::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 AccessDeniedCode {
    #[allow(missing_docs)] // documentation missing in model
    AccessDenied,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for AccessDeniedCode {
    fn from(s: &str) -> Self {
        match s {
            "accessDenied" => AccessDeniedCode::AccessDenied,
            other => AccessDeniedCode::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for AccessDeniedCode {
    type Err = std::convert::Infallible;

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

/// Describes one specific validation failure for an input member.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ValidationExceptionField {
    /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
    #[doc(hidden)]
    pub path: std::option::Option<std::string::String>,
    /// A detailed description of the validation failure.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
}
impl ValidationExceptionField {
    /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
    pub fn path(&self) -> std::option::Option<&str> {
        self.path.as_deref()
    }
    /// A detailed description of the validation failure.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
/// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).
pub mod validation_exception_field {

    /// A builder for [`ValidationExceptionField`](crate::model::ValidationExceptionField).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) path: std::option::Option<std::string::String>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
        pub fn path(mut self, input: impl Into<std::string::String>) -> Self {
            self.path = Some(input.into());
            self
        }
        /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
        pub fn set_path(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.path = input;
            self
        }
        /// A detailed description of the validation failure.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// A detailed description of the validation failure.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`ValidationExceptionField`](crate::model::ValidationExceptionField).
        pub fn build(self) -> crate::model::ValidationExceptionField {
            crate::model::ValidationExceptionField {
                path: self.path,
                message: self.message,
            }
        }
    }
}
impl ValidationExceptionField {
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
    pub fn builder() -> crate::model::validation_exception_field::Builder {
        crate::model::validation_exception_field::Builder::default()
    }
}

/// When writing a match expression against `ThrottleCode`, 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 throttlecode = unimplemented!();
/// match throttlecode {
///     ThrottleCode::LimitExceeded => { /* ... */ },
///     ThrottleCode::TooManyRequests => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `throttlecode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `ThrottleCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `ThrottleCode::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 `ThrottleCode::NewFeature` is defined.
/// Specifically, when `throttlecode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `ThrottleCode::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 ThrottleCode {
    #[allow(missing_docs)] // documentation missing in model
    LimitExceeded,
    #[allow(missing_docs)] // documentation missing in model
    TooManyRequests,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ThrottleCode {
    fn from(s: &str) -> Self {
        match s {
            "LimitExceeded" => ThrottleCode::LimitExceeded,
            "tooManyRequests" => ThrottleCode::TooManyRequests,
            other => ThrottleCode::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for ThrottleCode {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(ThrottleCode::from(s))
    }
}
impl ThrottleCode {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            ThrottleCode::LimitExceeded => "LimitExceeded",
            ThrottleCode::TooManyRequests => "tooManyRequests",
            ThrottleCode::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["LimitExceeded", "tooManyRequests"]
    }
}
impl AsRef<str> for ThrottleCode {
    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 InternalFailureData {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub unique_identifier: std::option::Option<std::string::String>,
}
impl InternalFailureData {
    #[allow(missing_docs)] // documentation missing in model
    pub fn unique_identifier(&self) -> std::option::Option<&str> {
        self.unique_identifier.as_deref()
    }
}
/// See [`InternalFailureData`](crate::model::InternalFailureData).
pub mod internal_failure_data {

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

/// When writing a match expression against `InternalFailureCode`, 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 internalfailurecode = unimplemented!();
/// match internalfailurecode {
///     InternalFailureCode::UnknownError => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `internalfailurecode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `InternalFailureCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `InternalFailureCode::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 `InternalFailureCode::NewFeature` is defined.
/// Specifically, when `internalfailurecode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `InternalFailureCode::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 InternalFailureCode {
    #[allow(missing_docs)] // documentation missing in model
    UnknownError,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for InternalFailureCode {
    fn from(s: &str) -> Self {
        match s {
            "unknownError" => InternalFailureCode::UnknownError,
            other => {
                InternalFailureCode::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
            }
        }
    }
}
impl std::str::FromStr for InternalFailureCode {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(InternalFailureCode::from(s))
    }
}
impl InternalFailureCode {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            InternalFailureCode::UnknownError => "unknownError",
            InternalFailureCode::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["unknownError"]
    }
}
impl AsRef<str> for InternalFailureCode {
    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 PublicSharedGuideSampleData {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub content: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub description: std::option::Option<std::string::String>,
}
impl PublicSharedGuideSampleData {
    #[allow(missing_docs)] // documentation missing in model
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn content(&self) -> std::option::Option<&str> {
        self.content.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn description(&self) -> std::option::Option<&str> {
        self.description.as_deref()
    }
}
/// See [`PublicSharedGuideSampleData`](crate::model::PublicSharedGuideSampleData).
pub mod public_shared_guide_sample_data {

    /// A builder for [`PublicSharedGuideSampleData`](crate::model::PublicSharedGuideSampleData).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) content: std::option::Option<std::string::String>,
        pub(crate) description: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        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 content(mut self, input: impl Into<std::string::String>) -> Self {
            self.content = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_content(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.content = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.description = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.description = input;
            self
        }
        /// Consumes the builder and constructs a [`PublicSharedGuideSampleData`](crate::model::PublicSharedGuideSampleData).
        pub fn build(self) -> crate::model::PublicSharedGuideSampleData {
            crate::model::PublicSharedGuideSampleData {
                id: self.id,
                name: self.name,
                content: self.content,
                description: self.description,
            }
        }
    }
}
impl PublicSharedGuideSampleData {
    /// Creates a new builder-style object to manufacture [`PublicSharedGuideSampleData`](crate::model::PublicSharedGuideSampleData).
    pub fn builder() -> crate::model::public_shared_guide_sample_data::Builder {
        crate::model::public_shared_guide_sample_data::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GuideTarget {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub standard: std::option::Option<crate::model::GuideStandard>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub release: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub transaction_set: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub hipaa_transaction_set_suffix: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub message_type: std::option::Option<std::string::String>,
}
impl GuideTarget {
    #[allow(missing_docs)] // documentation missing in model
    pub fn standard(&self) -> std::option::Option<&crate::model::GuideStandard> {
        self.standard.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn release(&self) -> std::option::Option<&str> {
        self.release.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn transaction_set(&self) -> std::option::Option<&str> {
        self.transaction_set.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn hipaa_transaction_set_suffix(&self) -> std::option::Option<&str> {
        self.hipaa_transaction_set_suffix.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn message_type(&self) -> std::option::Option<&str> {
        self.message_type.as_deref()
    }
}
/// See [`GuideTarget`](crate::model::GuideTarget).
pub mod guide_target {

    /// A builder for [`GuideTarget`](crate::model::GuideTarget).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) standard: std::option::Option<crate::model::GuideStandard>,
        pub(crate) release: std::option::Option<std::string::String>,
        pub(crate) transaction_set: std::option::Option<std::string::String>,
        pub(crate) hipaa_transaction_set_suffix: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
        pub(crate) message_type: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn standard(mut self, input: crate::model::GuideStandard) -> Self {
            self.standard = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_standard(
            mut self,
            input: std::option::Option<crate::model::GuideStandard>,
        ) -> Self {
            self.standard = input;
            self
        }
        #[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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn transaction_set(mut self, input: impl Into<std::string::String>) -> Self {
            self.transaction_set = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_transaction_set(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.transaction_set = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn hipaa_transaction_set_suffix(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.hipaa_transaction_set_suffix = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_hipaa_transaction_set_suffix(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.hipaa_transaction_set_suffix = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn message_type(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_type = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_message_type(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message_type = input;
            self
        }
        /// Consumes the builder and constructs a [`GuideTarget`](crate::model::GuideTarget).
        pub fn build(self) -> crate::model::GuideTarget {
            crate::model::GuideTarget {
                standard: self.standard,
                release: self.release,
                transaction_set: self.transaction_set,
                hipaa_transaction_set_suffix: self.hipaa_transaction_set_suffix,
                version: self.version,
                message_type: self.message_type,
            }
        }
    }
}
impl GuideTarget {
    /// Creates a new builder-style object to manufacture [`GuideTarget`](crate::model::GuideTarget).
    pub fn builder() -> crate::model::guide_target::Builder {
        crate::model::guide_target::Builder::default()
    }
}

/// When writing a match expression against `GuideStandard`, 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 guidestandard = unimplemented!();
/// match guidestandard {
///     GuideStandard::Edifact => { /* ... */ },
///     GuideStandard::X12 => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `guidestandard` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `GuideStandard::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `GuideStandard::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 `GuideStandard::NewFeature` is defined.
/// Specifically, when `guidestandard` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `GuideStandard::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 GuideStandard {
    #[allow(missing_docs)] // documentation missing in model
    Edifact,
    #[allow(missing_docs)] // documentation missing in model
    X12,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for GuideStandard {
    fn from(s: &str) -> Self {
        match s {
            "edifact" => GuideStandard::Edifact,
            "x12" => GuideStandard::X12,
            other => GuideStandard::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for GuideStandard {
    type Err = std::convert::Infallible;

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

/// When writing a match expression against `OutputFormat`, 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 outputformat = unimplemented!();
/// match outputformat {
///     OutputFormat::Default => { /* ... */ },
///     OutputFormat::Schema => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `outputformat` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `OutputFormat::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `OutputFormat::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 `OutputFormat::NewFeature` is defined.
/// Specifically, when `outputformat` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `OutputFormat::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 OutputFormat {
    #[allow(missing_docs)] // documentation missing in model
    Default,
    #[allow(missing_docs)] // documentation missing in model
    Schema,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for OutputFormat {
    fn from(s: &str) -> Self {
        match s {
            "default" => OutputFormat::Default,
            "schema" => OutputFormat::Schema,
            other => OutputFormat::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for OutputFormat {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(OutputFormat::from(s))
    }
}
impl OutputFormat {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            OutputFormat::Default => "default",
            OutputFormat::Schema => "schema",
            OutputFormat::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["default", "schema"]
    }
}
impl AsRef<str> for OutputFormat {
    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 PublicGuideSummary {
    /// Id of the published guide, begins with LIVE_
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub published_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub target: std::option::Option<crate::model::GuideTarget>,
}
impl PublicGuideSummary {
    /// Id of the published guide, begins with LIVE_
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn name(&self) -> std::option::Option<&str> {
        self.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()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn published_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.published_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn target(&self) -> std::option::Option<&crate::model::GuideTarget> {
        self.target.as_ref()
    }
}
/// See [`PublicGuideSummary`](crate::model::PublicGuideSummary).
pub mod public_guide_summary {

    /// A builder for [`PublicGuideSummary`](crate::model::PublicGuideSummary).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) 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) published_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) target: std::option::Option<crate::model::GuideTarget>,
    }
    impl Builder {
        /// Id of the published guide, begins with LIVE_
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// Id of the published guide, begins with LIVE_
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        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 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 published_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.published_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_published_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.published_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn target(mut self, input: crate::model::GuideTarget) -> Self {
            self.target = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_target(mut self, input: std::option::Option<crate::model::GuideTarget>) -> Self {
            self.target = input;
            self
        }
        /// Consumes the builder and constructs a [`PublicGuideSummary`](crate::model::PublicGuideSummary).
        pub fn build(self) -> crate::model::PublicGuideSummary {
            crate::model::PublicGuideSummary {
                id: self.id,
                name: self.name,
                created_at: self.created_at,
                updated_at: self.updated_at,
                published_at: self.published_at,
                target: self.target,
            }
        }
    }
}
impl PublicGuideSummary {
    /// Creates a new builder-style object to manufacture [`PublicGuideSummary`](crate::model::PublicGuideSummary).
    pub fn builder() -> crate::model::public_guide_summary::Builder {
        crate::model::public_guide_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PublicGuideSampleData {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub content: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub description: std::option::Option<std::string::String>,
}
impl PublicGuideSampleData {
    #[allow(missing_docs)] // documentation missing in model
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn content(&self) -> std::option::Option<&str> {
        self.content.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn description(&self) -> std::option::Option<&str> {
        self.description.as_deref()
    }
}
/// See [`PublicGuideSampleData`](crate::model::PublicGuideSampleData).
pub mod public_guide_sample_data {

    /// A builder for [`PublicGuideSampleData`](crate::model::PublicGuideSampleData).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) content: std::option::Option<std::string::String>,
        pub(crate) description: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        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 content(mut self, input: impl Into<std::string::String>) -> Self {
            self.content = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_content(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.content = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.description = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.description = input;
            self
        }
        /// Consumes the builder and constructs a [`PublicGuideSampleData`](crate::model::PublicGuideSampleData).
        pub fn build(self) -> crate::model::PublicGuideSampleData {
            crate::model::PublicGuideSampleData {
                id: self.id,
                name: self.name,
                content: self.content,
                description: self.description,
            }
        }
    }
}
impl PublicGuideSampleData {
    /// Creates a new builder-style object to manufacture [`PublicGuideSampleData`](crate::model::PublicGuideSampleData).
    pub fn builder() -> crate::model::public_guide_sample_data::Builder {
        crate::model::public_guide_sample_data::Builder::default()
    }
}

/// When writing a match expression against `GuideVisibility`, 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 guidevisibility = unimplemented!();
/// match guidevisibility {
///     GuideVisibility::External => { /* ... */ },
///     GuideVisibility::Internal => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `guidevisibility` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `GuideVisibility::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `GuideVisibility::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 `GuideVisibility::NewFeature` is defined.
/// Specifically, when `guidevisibility` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `GuideVisibility::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 GuideVisibility {
    #[allow(missing_docs)] // documentation missing in model
    External,
    #[allow(missing_docs)] // documentation missing in model
    Internal,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for GuideVisibility {
    fn from(s: &str) -> Self {
        match s {
            "external" => GuideVisibility::External,
            "internal" => GuideVisibility::Internal,
            other => GuideVisibility::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for GuideVisibility {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(GuideVisibility::from(s))
    }
}
impl GuideVisibility {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            GuideVisibility::External => "external",
            GuideVisibility::Internal => "internal",
            GuideVisibility::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["external", "internal"]
    }
}
impl AsRef<str> for GuideVisibility {
    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 GuideSummary {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub visibility: std::option::Option<crate::model::GuideVisibility>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub unpublished_changes: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub published_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub target: std::option::Option<crate::model::GuideTarget>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub share_enabled: std::option::Option<bool>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub share_id: std::option::Option<std::string::String>,
}
impl GuideSummary {
    #[allow(missing_docs)] // documentation missing in model
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn name(&self) -> std::option::Option<&str> {
        self.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()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn visibility(&self) -> std::option::Option<&crate::model::GuideVisibility> {
        self.visibility.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn unpublished_changes(&self) -> std::option::Option<bool> {
        self.unpublished_changes
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn published_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.published_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn target(&self) -> std::option::Option<&crate::model::GuideTarget> {
        self.target.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn share_enabled(&self) -> std::option::Option<bool> {
        self.share_enabled
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn share_id(&self) -> std::option::Option<&str> {
        self.share_id.as_deref()
    }
}
/// See [`GuideSummary`](crate::model::GuideSummary).
pub mod guide_summary {

    /// A builder for [`GuideSummary`](crate::model::GuideSummary).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) 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) visibility: std::option::Option<crate::model::GuideVisibility>,
        pub(crate) unpublished_changes: std::option::Option<bool>,
        pub(crate) published_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) target: std::option::Option<crate::model::GuideTarget>,
        pub(crate) share_enabled: std::option::Option<bool>,
        pub(crate) share_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        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 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 visibility(mut self, input: crate::model::GuideVisibility) -> Self {
            self.visibility = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_visibility(
            mut self,
            input: std::option::Option<crate::model::GuideVisibility>,
        ) -> Self {
            self.visibility = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn unpublished_changes(mut self, input: bool) -> Self {
            self.unpublished_changes = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_unpublished_changes(mut self, input: std::option::Option<bool>) -> Self {
            self.unpublished_changes = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn published_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.published_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_published_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.published_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn target(mut self, input: crate::model::GuideTarget) -> Self {
            self.target = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_target(mut self, input: std::option::Option<crate::model::GuideTarget>) -> Self {
            self.target = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn share_enabled(mut self, input: bool) -> Self {
            self.share_enabled = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_share_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.share_enabled = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn share_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.share_id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_share_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.share_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GuideSummary`](crate::model::GuideSummary).
        pub fn build(self) -> crate::model::GuideSummary {
            crate::model::GuideSummary {
                id: self.id,
                name: self.name,
                created_at: self.created_at,
                updated_at: self.updated_at,
                visibility: self.visibility,
                unpublished_changes: self.unpublished_changes,
                published_at: self.published_at,
                target: self.target,
                share_enabled: self.share_enabled,
                share_id: self.share_id,
            }
        }
    }
}
impl GuideSummary {
    /// Creates a new builder-style object to manufacture [`GuideSummary`](crate::model::GuideSummary).
    pub fn builder() -> crate::model::guide_summary::Builder {
        crate::model::guide_summary::Builder::default()
    }
}

/// When writing a match expression against `GuideStatus`, 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 guidestatus = unimplemented!();
/// match guidestatus {
///     GuideStatus::Draft => { /* ... */ },
///     GuideStatus::Live => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `guidestatus` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `GuideStatus::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `GuideStatus::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 `GuideStatus::NewFeature` is defined.
/// Specifically, when `guidestatus` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `GuideStatus::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 GuideStatus {
    #[allow(missing_docs)] // documentation missing in model
    Draft,
    #[allow(missing_docs)] // documentation missing in model
    Live,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for GuideStatus {
    fn from(s: &str) -> Self {
        match s {
            "draft" => GuideStatus::Draft,
            "live" => GuideStatus::Live,
            other => GuideStatus::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for GuideStatus {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(GuideStatus::from(s))
    }
}
impl GuideStatus {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            GuideStatus::Draft => "draft",
            GuideStatus::Live => "live",
            GuideStatus::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["draft", "live"]
    }
}
impl AsRef<str> for GuideStatus {
    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 ResponseTooLargeData {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub max_size: std::option::Option<i32>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub response_size: std::option::Option<i32>,
}
impl ResponseTooLargeData {
    #[allow(missing_docs)] // documentation missing in model
    pub fn max_size(&self) -> std::option::Option<i32> {
        self.max_size
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn response_size(&self) -> std::option::Option<i32> {
        self.response_size
    }
}
/// See [`ResponseTooLargeData`](crate::model::ResponseTooLargeData).
pub mod response_too_large_data {

    /// A builder for [`ResponseTooLargeData`](crate::model::ResponseTooLargeData).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) max_size: std::option::Option<i32>,
        pub(crate) response_size: std::option::Option<i32>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn max_size(mut self, input: i32) -> Self {
            self.max_size = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_max_size(mut self, input: std::option::Option<i32>) -> Self {
            self.max_size = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn response_size(mut self, input: i32) -> Self {
            self.response_size = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_response_size(mut self, input: std::option::Option<i32>) -> Self {
            self.response_size = input;
            self
        }
        /// Consumes the builder and constructs a [`ResponseTooLargeData`](crate::model::ResponseTooLargeData).
        pub fn build(self) -> crate::model::ResponseTooLargeData {
            crate::model::ResponseTooLargeData {
                max_size: self.max_size,
                response_size: self.response_size,
            }
        }
    }
}
impl ResponseTooLargeData {
    /// Creates a new builder-style object to manufacture [`ResponseTooLargeData`](crate::model::ResponseTooLargeData).
    pub fn builder() -> crate::model::response_too_large_data::Builder {
        crate::model::response_too_large_data::Builder::default()
    }
}

/// When writing a match expression against `ResponseTooLargeCode`, 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 responsetoolargecode = unimplemented!();
/// match responsetoolargecode {
///     ResponseTooLargeCode::ResponseTooLarge => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `responsetoolargecode` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `ResponseTooLargeCode::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `ResponseTooLargeCode::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 `ResponseTooLargeCode::NewFeature` is defined.
/// Specifically, when `responsetoolargecode` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `ResponseTooLargeCode::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 ResponseTooLargeCode {
    #[allow(missing_docs)] // documentation missing in model
    ResponseTooLarge,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ResponseTooLargeCode {
    fn from(s: &str) -> Self {
        match s {
            "responseTooLarge" => ResponseTooLargeCode::ResponseTooLarge,
            other => {
                ResponseTooLargeCode::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
            }
        }
    }
}
impl std::str::FromStr for ResponseTooLargeCode {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(ResponseTooLargeCode::from(s))
    }
}
impl ResponseTooLargeCode {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            ResponseTooLargeCode::ResponseTooLarge => "responseTooLarge",
            ResponseTooLargeCode::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["responseTooLarge"]
    }
}
impl AsRef<str> for ResponseTooLargeCode {
    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 GuideSampleData {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub content: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub description: std::option::Option<std::string::String>,
}
impl GuideSampleData {
    #[allow(missing_docs)] // documentation missing in model
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn content(&self) -> std::option::Option<&str> {
        self.content.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn description(&self) -> std::option::Option<&str> {
        self.description.as_deref()
    }
}
/// See [`GuideSampleData`](crate::model::GuideSampleData).
pub mod guide_sample_data {

    /// A builder for [`GuideSampleData`](crate::model::GuideSampleData).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) content: std::option::Option<std::string::String>,
        pub(crate) description: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        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 content(mut self, input: impl Into<std::string::String>) -> Self {
            self.content = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_content(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.content = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.description = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.description = input;
            self
        }
        /// Consumes the builder and constructs a [`GuideSampleData`](crate::model::GuideSampleData).
        pub fn build(self) -> crate::model::GuideSampleData {
            crate::model::GuideSampleData {
                id: self.id,
                name: self.name,
                content: self.content,
                description: self.description,
            }
        }
    }
}
impl GuideSampleData {
    /// Creates a new builder-style object to manufacture [`GuideSampleData`](crate::model::GuideSampleData).
    pub fn builder() -> crate::model::guide_sample_data::Builder {
        crate::model::guide_sample_data::Builder::default()
    }
}

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

    /// A builder for [`TransactionSetSummary`](crate::model::TransactionSetSummary).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) description: std::option::Option<std::string::String>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        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 description(mut self, input: impl Into<std::string::String>) -> Self {
            self.description = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.description = input;
            self
        }
        /// Consumes the builder and constructs a [`TransactionSetSummary`](crate::model::TransactionSetSummary).
        pub fn build(self) -> crate::model::TransactionSetSummary {
            crate::model::TransactionSetSummary {
                id: self.id,
                name: self.name,
                description: self.description,
            }
        }
    }
}
impl TransactionSetSummary {
    /// Creates a new builder-style object to manufacture [`TransactionSetSummary`](crate::model::TransactionSetSummary).
    pub fn builder() -> crate::model::transaction_set_summary::Builder {
        crate::model::transaction_set_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AllPublicGuideSummary {
    /// Id of the published guide, begins with LIVE_
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub published_at: std::option::Option<aws_smithy_types::DateTime>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub target: std::option::Option<crate::model::GuideTarget>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub account_config: std::option::Option<crate::model::AccountConfigSummary>,
}
impl AllPublicGuideSummary {
    /// Id of the published guide, begins with LIVE_
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn name(&self) -> std::option::Option<&str> {
        self.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()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn published_at(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.published_at.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn target(&self) -> std::option::Option<&crate::model::GuideTarget> {
        self.target.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn account_config(&self) -> std::option::Option<&crate::model::AccountConfigSummary> {
        self.account_config.as_ref()
    }
}
/// See [`AllPublicGuideSummary`](crate::model::AllPublicGuideSummary).
pub mod all_public_guide_summary {

    /// A builder for [`AllPublicGuideSummary`](crate::model::AllPublicGuideSummary).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) 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) published_at: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) target: std::option::Option<crate::model::GuideTarget>,
        pub(crate) account_config: std::option::Option<crate::model::AccountConfigSummary>,
    }
    impl Builder {
        /// Id of the published guide, begins with LIVE_
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// Id of the published guide, begins with LIVE_
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        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 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 published_at(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.published_at = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_published_at(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.published_at = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn target(mut self, input: crate::model::GuideTarget) -> Self {
            self.target = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_target(mut self, input: std::option::Option<crate::model::GuideTarget>) -> Self {
            self.target = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn account_config(mut self, input: crate::model::AccountConfigSummary) -> Self {
            self.account_config = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_account_config(
            mut self,
            input: std::option::Option<crate::model::AccountConfigSummary>,
        ) -> Self {
            self.account_config = input;
            self
        }
        /// Consumes the builder and constructs a [`AllPublicGuideSummary`](crate::model::AllPublicGuideSummary).
        pub fn build(self) -> crate::model::AllPublicGuideSummary {
            crate::model::AllPublicGuideSummary {
                id: self.id,
                name: self.name,
                created_at: self.created_at,
                updated_at: self.updated_at,
                published_at: self.published_at,
                target: self.target,
                account_config: self.account_config,
            }
        }
    }
}
impl AllPublicGuideSummary {
    /// Creates a new builder-style object to manufacture [`AllPublicGuideSummary`](crate::model::AllPublicGuideSummary).
    pub fn builder() -> crate::model::all_public_guide_summary::Builder {
        crate::model::all_public_guide_summary::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AccountConfigSummary {
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub logo_url: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub link_text: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub link_url: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub slug: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub display_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>,
}
impl AccountConfigSummary {
    #[allow(missing_docs)] // documentation missing in model
    pub fn logo_url(&self) -> std::option::Option<&str> {
        self.logo_url.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn link_text(&self) -> std::option::Option<&str> {
        self.link_text.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn link_url(&self) -> std::option::Option<&str> {
        self.link_url.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn slug(&self) -> std::option::Option<&str> {
        self.slug.as_deref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn display_name(&self) -> std::option::Option<&str> {
        self.display_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()
    }
}
/// See [`AccountConfigSummary`](crate::model::AccountConfigSummary).
pub mod account_config_summary {

    /// A builder for [`AccountConfigSummary`](crate::model::AccountConfigSummary).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) logo_url: std::option::Option<std::string::String>,
        pub(crate) link_text: std::option::Option<std::string::String>,
        pub(crate) link_url: std::option::Option<std::string::String>,
        pub(crate) slug: std::option::Option<std::string::String>,
        pub(crate) display_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>,
    }
    impl Builder {
        #[allow(missing_docs)] // documentation missing in model
        pub fn logo_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.logo_url = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_logo_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.logo_url = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn link_text(mut self, input: impl Into<std::string::String>) -> Self {
            self.link_text = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_link_text(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.link_text = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn link_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.link_url = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_link_url(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.link_url = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn slug(mut self, input: impl Into<std::string::String>) -> Self {
            self.slug = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_slug(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.slug = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.display_name = Some(input.into());
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.display_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
        }
        /// Consumes the builder and constructs a [`AccountConfigSummary`](crate::model::AccountConfigSummary).
        pub fn build(self) -> crate::model::AccountConfigSummary {
            crate::model::AccountConfigSummary {
                logo_url: self.logo_url,
                link_text: self.link_text,
                link_url: self.link_url,
                slug: self.slug,
                display_name: self.display_name,
                created_at: self.created_at,
                updated_at: self.updated_at,
            }
        }
    }
}
impl AccountConfigSummary {
    /// Creates a new builder-style object to manufacture [`AccountConfigSummary`](crate::model::AccountConfigSummary).
    pub fn builder() -> crate::model::account_config_summary::Builder {
        crate::model::account_config_summary::Builder::default()
    }
}