// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateUserOutput {
    /// <p>The updated user</p>
    pub user: std::option::Option<crate::model::User>,
}
impl UpdateUserOutput {
    /// <p>The updated user</p>
    pub fn user(&self) -> std::option::Option<&crate::model::User> {
        self.user.as_ref()
    }
}
impl std::fmt::Debug for UpdateUserOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateUserOutput");
        formatter.field("user", &self.user);
        formatter.finish()
    }
}
/// See [`UpdateUserOutput`](crate::output::UpdateUserOutput)
pub mod update_user_output {
    /// A builder for [`UpdateUserOutput`](crate::output::UpdateUserOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) user: std::option::Option<crate::model::User>,
    }
    impl Builder {
        /// <p>The updated user</p>
        pub fn user(mut self, input: crate::model::User) -> Self {
            self.user = Some(input);
            self
        }
        /// <p>The updated user</p>
        pub fn set_user(mut self, input: std::option::Option<crate::model::User>) -> Self {
            self.user = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateUserOutput`](crate::output::UpdateUserOutput)
        pub fn build(self) -> crate::output::UpdateUserOutput {
            crate::output::UpdateUserOutput { user: self.user }
        }
    }
}
impl UpdateUserOutput {
    /// Creates a new builder-style object to manufacture [`UpdateUserOutput`](crate::output::UpdateUserOutput)
    pub fn builder() -> crate::output::update_user_output::Builder {
        crate::output::update_user_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateSubnetGroupOutput {
    /// <p>The updated subnet group</p>
    pub subnet_group: std::option::Option<crate::model::SubnetGroup>,
}
impl UpdateSubnetGroupOutput {
    /// <p>The updated subnet group</p>
    pub fn subnet_group(&self) -> std::option::Option<&crate::model::SubnetGroup> {
        self.subnet_group.as_ref()
    }
}
impl std::fmt::Debug for UpdateSubnetGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateSubnetGroupOutput");
        formatter.field("subnet_group", &self.subnet_group);
        formatter.finish()
    }
}
/// See [`UpdateSubnetGroupOutput`](crate::output::UpdateSubnetGroupOutput)
pub mod update_subnet_group_output {
    /// A builder for [`UpdateSubnetGroupOutput`](crate::output::UpdateSubnetGroupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) subnet_group: std::option::Option<crate::model::SubnetGroup>,
    }
    impl Builder {
        /// <p>The updated subnet group</p>
        pub fn subnet_group(mut self, input: crate::model::SubnetGroup) -> Self {
            self.subnet_group = Some(input);
            self
        }
        /// <p>The updated subnet group</p>
        pub fn set_subnet_group(
            mut self,
            input: std::option::Option<crate::model::SubnetGroup>,
        ) -> Self {
            self.subnet_group = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateSubnetGroupOutput`](crate::output::UpdateSubnetGroupOutput)
        pub fn build(self) -> crate::output::UpdateSubnetGroupOutput {
            crate::output::UpdateSubnetGroupOutput {
                subnet_group: self.subnet_group,
            }
        }
    }
}
impl UpdateSubnetGroupOutput {
    /// Creates a new builder-style object to manufacture [`UpdateSubnetGroupOutput`](crate::output::UpdateSubnetGroupOutput)
    pub fn builder() -> crate::output::update_subnet_group_output::Builder {
        crate::output::update_subnet_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateParameterGroupOutput {
    /// <p>The updated parameter group</p>
    pub parameter_group: std::option::Option<crate::model::ParameterGroup>,
}
impl UpdateParameterGroupOutput {
    /// <p>The updated parameter group</p>
    pub fn parameter_group(&self) -> std::option::Option<&crate::model::ParameterGroup> {
        self.parameter_group.as_ref()
    }
}
impl std::fmt::Debug for UpdateParameterGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateParameterGroupOutput");
        formatter.field("parameter_group", &self.parameter_group);
        formatter.finish()
    }
}
/// See [`UpdateParameterGroupOutput`](crate::output::UpdateParameterGroupOutput)
pub mod update_parameter_group_output {
    /// A builder for [`UpdateParameterGroupOutput`](crate::output::UpdateParameterGroupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) parameter_group: std::option::Option<crate::model::ParameterGroup>,
    }
    impl Builder {
        /// <p>The updated parameter group</p>
        pub fn parameter_group(mut self, input: crate::model::ParameterGroup) -> Self {
            self.parameter_group = Some(input);
            self
        }
        /// <p>The updated parameter group</p>
        pub fn set_parameter_group(
            mut self,
            input: std::option::Option<crate::model::ParameterGroup>,
        ) -> Self {
            self.parameter_group = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateParameterGroupOutput`](crate::output::UpdateParameterGroupOutput)
        pub fn build(self) -> crate::output::UpdateParameterGroupOutput {
            crate::output::UpdateParameterGroupOutput {
                parameter_group: self.parameter_group,
            }
        }
    }
}
impl UpdateParameterGroupOutput {
    /// Creates a new builder-style object to manufacture [`UpdateParameterGroupOutput`](crate::output::UpdateParameterGroupOutput)
    pub fn builder() -> crate::output::update_parameter_group_output::Builder {
        crate::output::update_parameter_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateClusterOutput {
    /// <p>The updated cluster</p>
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl UpdateClusterOutput {
    /// <p>The updated cluster</p>
    pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
        self.cluster.as_ref()
    }
}
impl std::fmt::Debug for UpdateClusterOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateClusterOutput");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}
/// See [`UpdateClusterOutput`](crate::output::UpdateClusterOutput)
pub mod update_cluster_output {
    /// A builder for [`UpdateClusterOutput`](crate::output::UpdateClusterOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster: std::option::Option<crate::model::Cluster>,
    }
    impl Builder {
        /// <p>The updated cluster</p>
        pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
            self.cluster = Some(input);
            self
        }
        /// <p>The updated cluster</p>
        pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
            self.cluster = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateClusterOutput`](crate::output::UpdateClusterOutput)
        pub fn build(self) -> crate::output::UpdateClusterOutput {
            crate::output::UpdateClusterOutput {
                cluster: self.cluster,
            }
        }
    }
}
impl UpdateClusterOutput {
    /// Creates a new builder-style object to manufacture [`UpdateClusterOutput`](crate::output::UpdateClusterOutput)
    pub fn builder() -> crate::output::update_cluster_output::Builder {
        crate::output::update_cluster_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateAclOutput {
    /// <p>The updated Access Control List</p>
    pub acl: std::option::Option<crate::model::Acl>,
}
impl UpdateAclOutput {
    /// <p>The updated Access Control List</p>
    pub fn acl(&self) -> std::option::Option<&crate::model::Acl> {
        self.acl.as_ref()
    }
}
impl std::fmt::Debug for UpdateAclOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateAclOutput");
        formatter.field("acl", &self.acl);
        formatter.finish()
    }
}
/// See [`UpdateAclOutput`](crate::output::UpdateAclOutput)
pub mod update_acl_output {
    /// A builder for [`UpdateAclOutput`](crate::output::UpdateAclOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) acl: std::option::Option<crate::model::Acl>,
    }
    impl Builder {
        /// <p>The updated Access Control List</p>
        pub fn acl(mut self, input: crate::model::Acl) -> Self {
            self.acl = Some(input);
            self
        }
        /// <p>The updated Access Control List</p>
        pub fn set_acl(mut self, input: std::option::Option<crate::model::Acl>) -> Self {
            self.acl = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateAclOutput`](crate::output::UpdateAclOutput)
        pub fn build(self) -> crate::output::UpdateAclOutput {
            crate::output::UpdateAclOutput { acl: self.acl }
        }
    }
}
impl UpdateAclOutput {
    /// Creates a new builder-style object to manufacture [`UpdateAclOutput`](crate::output::UpdateAclOutput)
    pub fn builder() -> crate::output::update_acl_output::Builder {
        crate::output::update_acl_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UntagResourceOutput {
    /// <p>The list of tags removed</p>
    pub tag_list: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl UntagResourceOutput {
    /// <p>The list of tags removed</p>
    pub fn tag_list(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tag_list.as_deref()
    }
}
impl std::fmt::Debug for UntagResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UntagResourceOutput");
        formatter.field("tag_list", &self.tag_list);
        formatter.finish()
    }
}
/// See [`UntagResourceOutput`](crate::output::UntagResourceOutput)
pub mod untag_resource_output {
    /// A builder for [`UntagResourceOutput`](crate::output::UntagResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tag_list: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    }
    impl Builder {
        /// Appends an item to `tag_list`.
        ///
        /// To override the contents of this collection use [`set_tag_list`](Self::set_tag_list).
        ///
        /// <p>The list of tags removed</p>
        pub fn tag_list(mut self, input: impl Into<crate::model::Tag>) -> Self {
            let mut v = self.tag_list.unwrap_or_default();
            v.push(input.into());
            self.tag_list = Some(v);
            self
        }
        /// <p>The list of tags removed</p>
        pub fn set_tag_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tag_list = input;
            self
        }
        /// Consumes the builder and constructs a [`UntagResourceOutput`](crate::output::UntagResourceOutput)
        pub fn build(self) -> crate::output::UntagResourceOutput {
            crate::output::UntagResourceOutput {
                tag_list: self.tag_list,
            }
        }
    }
}
impl UntagResourceOutput {
    /// Creates a new builder-style object to manufacture [`UntagResourceOutput`](crate::output::UntagResourceOutput)
    pub fn builder() -> crate::output::untag_resource_output::Builder {
        crate::output::untag_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct TagResourceOutput {
    /// <p>A list of tags as key-value pairs.</p>
    pub tag_list: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl TagResourceOutput {
    /// <p>A list of tags as key-value pairs.</p>
    pub fn tag_list(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tag_list.as_deref()
    }
}
impl std::fmt::Debug for TagResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("TagResourceOutput");
        formatter.field("tag_list", &self.tag_list);
        formatter.finish()
    }
}
/// See [`TagResourceOutput`](crate::output::TagResourceOutput)
pub mod tag_resource_output {
    /// A builder for [`TagResourceOutput`](crate::output::TagResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tag_list: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    }
    impl Builder {
        /// Appends an item to `tag_list`.
        ///
        /// To override the contents of this collection use [`set_tag_list`](Self::set_tag_list).
        ///
        /// <p>A list of tags as key-value pairs.</p>
        pub fn tag_list(mut self, input: impl Into<crate::model::Tag>) -> Self {
            let mut v = self.tag_list.unwrap_or_default();
            v.push(input.into());
            self.tag_list = Some(v);
            self
        }
        /// <p>A list of tags as key-value pairs.</p>
        pub fn set_tag_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tag_list = input;
            self
        }
        /// Consumes the builder and constructs a [`TagResourceOutput`](crate::output::TagResourceOutput)
        pub fn build(self) -> crate::output::TagResourceOutput {
            crate::output::TagResourceOutput {
                tag_list: self.tag_list,
            }
        }
    }
}
impl TagResourceOutput {
    /// Creates a new builder-style object to manufacture [`TagResourceOutput`](crate::output::TagResourceOutput)
    pub fn builder() -> crate::output::tag_resource_output::Builder {
        crate::output::tag_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ResetParameterGroupOutput {
    /// <p>The parameter group being reset.</p>
    pub parameter_group: std::option::Option<crate::model::ParameterGroup>,
}
impl ResetParameterGroupOutput {
    /// <p>The parameter group being reset.</p>
    pub fn parameter_group(&self) -> std::option::Option<&crate::model::ParameterGroup> {
        self.parameter_group.as_ref()
    }
}
impl std::fmt::Debug for ResetParameterGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ResetParameterGroupOutput");
        formatter.field("parameter_group", &self.parameter_group);
        formatter.finish()
    }
}
/// See [`ResetParameterGroupOutput`](crate::output::ResetParameterGroupOutput)
pub mod reset_parameter_group_output {
    /// A builder for [`ResetParameterGroupOutput`](crate::output::ResetParameterGroupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) parameter_group: std::option::Option<crate::model::ParameterGroup>,
    }
    impl Builder {
        /// <p>The parameter group being reset.</p>
        pub fn parameter_group(mut self, input: crate::model::ParameterGroup) -> Self {
            self.parameter_group = Some(input);
            self
        }
        /// <p>The parameter group being reset.</p>
        pub fn set_parameter_group(
            mut self,
            input: std::option::Option<crate::model::ParameterGroup>,
        ) -> Self {
            self.parameter_group = input;
            self
        }
        /// Consumes the builder and constructs a [`ResetParameterGroupOutput`](crate::output::ResetParameterGroupOutput)
        pub fn build(self) -> crate::output::ResetParameterGroupOutput {
            crate::output::ResetParameterGroupOutput {
                parameter_group: self.parameter_group,
            }
        }
    }
}
impl ResetParameterGroupOutput {
    /// Creates a new builder-style object to manufacture [`ResetParameterGroupOutput`](crate::output::ResetParameterGroupOutput)
    pub fn builder() -> crate::output::reset_parameter_group_output::Builder {
        crate::output::reset_parameter_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsOutput {
    /// <p>A list of tags as key-value pairs.</p>
    pub tag_list: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl ListTagsOutput {
    /// <p>A list of tags as key-value pairs.</p>
    pub fn tag_list(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tag_list.as_deref()
    }
}
impl std::fmt::Debug for ListTagsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsOutput");
        formatter.field("tag_list", &self.tag_list);
        formatter.finish()
    }
}
/// See [`ListTagsOutput`](crate::output::ListTagsOutput)
pub mod list_tags_output {
    /// A builder for [`ListTagsOutput`](crate::output::ListTagsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tag_list: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    }
    impl Builder {
        /// Appends an item to `tag_list`.
        ///
        /// To override the contents of this collection use [`set_tag_list`](Self::set_tag_list).
        ///
        /// <p>A list of tags as key-value pairs.</p>
        pub fn tag_list(mut self, input: impl Into<crate::model::Tag>) -> Self {
            let mut v = self.tag_list.unwrap_or_default();
            v.push(input.into());
            self.tag_list = Some(v);
            self
        }
        /// <p>A list of tags as key-value pairs.</p>
        pub fn set_tag_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tag_list = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTagsOutput`](crate::output::ListTagsOutput)
        pub fn build(self) -> crate::output::ListTagsOutput {
            crate::output::ListTagsOutput {
                tag_list: self.tag_list,
            }
        }
    }
}
impl ListTagsOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsOutput`](crate::output::ListTagsOutput)
    pub fn builder() -> crate::output::list_tags_output::Builder {
        crate::output::list_tags_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListAllowedNodeTypeUpdatesOutput {
    /// <p>A list node types which you can use to scale up your cluster.</p>
    pub scale_up_node_types: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>A list node types which you can use to scale down your cluster.</p>
    pub scale_down_node_types: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl ListAllowedNodeTypeUpdatesOutput {
    /// <p>A list node types which you can use to scale up your cluster.</p>
    pub fn scale_up_node_types(&self) -> std::option::Option<&[std::string::String]> {
        self.scale_up_node_types.as_deref()
    }
    /// <p>A list node types which you can use to scale down your cluster.</p>
    pub fn scale_down_node_types(&self) -> std::option::Option<&[std::string::String]> {
        self.scale_down_node_types.as_deref()
    }
}
impl std::fmt::Debug for ListAllowedNodeTypeUpdatesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListAllowedNodeTypeUpdatesOutput");
        formatter.field("scale_up_node_types", &self.scale_up_node_types);
        formatter.field("scale_down_node_types", &self.scale_down_node_types);
        formatter.finish()
    }
}
/// See [`ListAllowedNodeTypeUpdatesOutput`](crate::output::ListAllowedNodeTypeUpdatesOutput)
pub mod list_allowed_node_type_updates_output {
    /// A builder for [`ListAllowedNodeTypeUpdatesOutput`](crate::output::ListAllowedNodeTypeUpdatesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) scale_up_node_types: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) scale_down_node_types: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        /// Appends an item to `scale_up_node_types`.
        ///
        /// To override the contents of this collection use [`set_scale_up_node_types`](Self::set_scale_up_node_types).
        ///
        /// <p>A list node types which you can use to scale up your cluster.</p>
        pub fn scale_up_node_types(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.scale_up_node_types.unwrap_or_default();
            v.push(input.into());
            self.scale_up_node_types = Some(v);
            self
        }
        /// <p>A list node types which you can use to scale up your cluster.</p>
        pub fn set_scale_up_node_types(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.scale_up_node_types = input;
            self
        }
        /// Appends an item to `scale_down_node_types`.
        ///
        /// To override the contents of this collection use [`set_scale_down_node_types`](Self::set_scale_down_node_types).
        ///
        /// <p>A list node types which you can use to scale down your cluster.</p>
        pub fn scale_down_node_types(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.scale_down_node_types.unwrap_or_default();
            v.push(input.into());
            self.scale_down_node_types = Some(v);
            self
        }
        /// <p>A list node types which you can use to scale down your cluster.</p>
        pub fn set_scale_down_node_types(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.scale_down_node_types = input;
            self
        }
        /// Consumes the builder and constructs a [`ListAllowedNodeTypeUpdatesOutput`](crate::output::ListAllowedNodeTypeUpdatesOutput)
        pub fn build(self) -> crate::output::ListAllowedNodeTypeUpdatesOutput {
            crate::output::ListAllowedNodeTypeUpdatesOutput {
                scale_up_node_types: self.scale_up_node_types,
                scale_down_node_types: self.scale_down_node_types,
            }
        }
    }
}
impl ListAllowedNodeTypeUpdatesOutput {
    /// Creates a new builder-style object to manufacture [`ListAllowedNodeTypeUpdatesOutput`](crate::output::ListAllowedNodeTypeUpdatesOutput)
    pub fn builder() -> crate::output::list_allowed_node_type_updates_output::Builder {
        crate::output::list_allowed_node_type_updates_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct FailoverShardOutput {
    /// <p>The cluster being failed over</p>
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl FailoverShardOutput {
    /// <p>The cluster being failed over</p>
    pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
        self.cluster.as_ref()
    }
}
impl std::fmt::Debug for FailoverShardOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("FailoverShardOutput");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}
/// See [`FailoverShardOutput`](crate::output::FailoverShardOutput)
pub mod failover_shard_output {
    /// A builder for [`FailoverShardOutput`](crate::output::FailoverShardOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster: std::option::Option<crate::model::Cluster>,
    }
    impl Builder {
        /// <p>The cluster being failed over</p>
        pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
            self.cluster = Some(input);
            self
        }
        /// <p>The cluster being failed over</p>
        pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
            self.cluster = input;
            self
        }
        /// Consumes the builder and constructs a [`FailoverShardOutput`](crate::output::FailoverShardOutput)
        pub fn build(self) -> crate::output::FailoverShardOutput {
            crate::output::FailoverShardOutput {
                cluster: self.cluster,
            }
        }
    }
}
impl FailoverShardOutput {
    /// Creates a new builder-style object to manufacture [`FailoverShardOutput`](crate::output::FailoverShardOutput)
    pub fn builder() -> crate::output::failover_shard_output::Builder {
        crate::output::failover_shard_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeUsersOutput {
    /// <p>A list of users.</p>
    pub users: std::option::Option<std::vec::Vec<crate::model::User>>,
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeUsersOutput {
    /// <p>A list of users.</p>
    pub fn users(&self) -> std::option::Option<&[crate::model::User]> {
        self.users.as_deref()
    }
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeUsersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeUsersOutput");
        formatter.field("users", &self.users);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeUsersOutput`](crate::output::DescribeUsersOutput)
pub mod describe_users_output {
    /// A builder for [`DescribeUsersOutput`](crate::output::DescribeUsersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) users: std::option::Option<std::vec::Vec<crate::model::User>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `users`.
        ///
        /// To override the contents of this collection use [`set_users`](Self::set_users).
        ///
        /// <p>A list of users.</p>
        pub fn users(mut self, input: impl Into<crate::model::User>) -> Self {
            let mut v = self.users.unwrap_or_default();
            v.push(input.into());
            self.users = Some(v);
            self
        }
        /// <p>A list of users.</p>
        pub fn set_users(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::User>>,
        ) -> Self {
            self.users = input;
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeUsersOutput`](crate::output::DescribeUsersOutput)
        pub fn build(self) -> crate::output::DescribeUsersOutput {
            crate::output::DescribeUsersOutput {
                users: self.users,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeUsersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeUsersOutput`](crate::output::DescribeUsersOutput)
    pub fn builder() -> crate::output::describe_users_output::Builder {
        crate::output::describe_users_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeSubnetGroupsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>A list of subnet groups. Each element in the list contains detailed information about one group.</p>
    pub subnet_groups: std::option::Option<std::vec::Vec<crate::model::SubnetGroup>>,
}
impl DescribeSubnetGroupsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>A list of subnet groups. Each element in the list contains detailed information about one group.</p>
    pub fn subnet_groups(&self) -> std::option::Option<&[crate::model::SubnetGroup]> {
        self.subnet_groups.as_deref()
    }
}
impl std::fmt::Debug for DescribeSubnetGroupsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeSubnetGroupsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("subnet_groups", &self.subnet_groups);
        formatter.finish()
    }
}
/// See [`DescribeSubnetGroupsOutput`](crate::output::DescribeSubnetGroupsOutput)
pub mod describe_subnet_groups_output {
    /// A builder for [`DescribeSubnetGroupsOutput`](crate::output::DescribeSubnetGroupsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) subnet_groups: std::option::Option<std::vec::Vec<crate::model::SubnetGroup>>,
    }
    impl Builder {
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `subnet_groups`.
        ///
        /// To override the contents of this collection use [`set_subnet_groups`](Self::set_subnet_groups).
        ///
        /// <p>A list of subnet groups. Each element in the list contains detailed information about one group.</p>
        pub fn subnet_groups(mut self, input: impl Into<crate::model::SubnetGroup>) -> Self {
            let mut v = self.subnet_groups.unwrap_or_default();
            v.push(input.into());
            self.subnet_groups = Some(v);
            self
        }
        /// <p>A list of subnet groups. Each element in the list contains detailed information about one group.</p>
        pub fn set_subnet_groups(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::SubnetGroup>>,
        ) -> Self {
            self.subnet_groups = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeSubnetGroupsOutput`](crate::output::DescribeSubnetGroupsOutput)
        pub fn build(self) -> crate::output::DescribeSubnetGroupsOutput {
            crate::output::DescribeSubnetGroupsOutput {
                next_token: self.next_token,
                subnet_groups: self.subnet_groups,
            }
        }
    }
}
impl DescribeSubnetGroupsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeSubnetGroupsOutput`](crate::output::DescribeSubnetGroupsOutput)
    pub fn builder() -> crate::output::describe_subnet_groups_output::Builder {
        crate::output::describe_subnet_groups_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeSnapshotsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>A list of snapshots. Each item in the list contains detailed information about one snapshot.</p>
    pub snapshots: std::option::Option<std::vec::Vec<crate::model::Snapshot>>,
}
impl DescribeSnapshotsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>A list of snapshots. Each item in the list contains detailed information about one snapshot.</p>
    pub fn snapshots(&self) -> std::option::Option<&[crate::model::Snapshot]> {
        self.snapshots.as_deref()
    }
}
impl std::fmt::Debug for DescribeSnapshotsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeSnapshotsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("snapshots", &self.snapshots);
        formatter.finish()
    }
}
/// See [`DescribeSnapshotsOutput`](crate::output::DescribeSnapshotsOutput)
pub mod describe_snapshots_output {
    /// A builder for [`DescribeSnapshotsOutput`](crate::output::DescribeSnapshotsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) snapshots: std::option::Option<std::vec::Vec<crate::model::Snapshot>>,
    }
    impl Builder {
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `snapshots`.
        ///
        /// To override the contents of this collection use [`set_snapshots`](Self::set_snapshots).
        ///
        /// <p>A list of snapshots. Each item in the list contains detailed information about one snapshot.</p>
        pub fn snapshots(mut self, input: impl Into<crate::model::Snapshot>) -> Self {
            let mut v = self.snapshots.unwrap_or_default();
            v.push(input.into());
            self.snapshots = Some(v);
            self
        }
        /// <p>A list of snapshots. Each item in the list contains detailed information about one snapshot.</p>
        pub fn set_snapshots(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Snapshot>>,
        ) -> Self {
            self.snapshots = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeSnapshotsOutput`](crate::output::DescribeSnapshotsOutput)
        pub fn build(self) -> crate::output::DescribeSnapshotsOutput {
            crate::output::DescribeSnapshotsOutput {
                next_token: self.next_token,
                snapshots: self.snapshots,
            }
        }
    }
}
impl DescribeSnapshotsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeSnapshotsOutput`](crate::output::DescribeSnapshotsOutput)
    pub fn builder() -> crate::output::describe_snapshots_output::Builder {
        crate::output::describe_snapshots_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeServiceUpdatesOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>A list of service updates</p>
    pub service_updates: std::option::Option<std::vec::Vec<crate::model::ServiceUpdate>>,
}
impl DescribeServiceUpdatesOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>A list of service updates</p>
    pub fn service_updates(&self) -> std::option::Option<&[crate::model::ServiceUpdate]> {
        self.service_updates.as_deref()
    }
}
impl std::fmt::Debug for DescribeServiceUpdatesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeServiceUpdatesOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("service_updates", &self.service_updates);
        formatter.finish()
    }
}
/// See [`DescribeServiceUpdatesOutput`](crate::output::DescribeServiceUpdatesOutput)
pub mod describe_service_updates_output {
    /// A builder for [`DescribeServiceUpdatesOutput`](crate::output::DescribeServiceUpdatesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) service_updates: std::option::Option<std::vec::Vec<crate::model::ServiceUpdate>>,
    }
    impl Builder {
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `service_updates`.
        ///
        /// To override the contents of this collection use [`set_service_updates`](Self::set_service_updates).
        ///
        /// <p>A list of service updates</p>
        pub fn service_updates(mut self, input: impl Into<crate::model::ServiceUpdate>) -> Self {
            let mut v = self.service_updates.unwrap_or_default();
            v.push(input.into());
            self.service_updates = Some(v);
            self
        }
        /// <p>A list of service updates</p>
        pub fn set_service_updates(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ServiceUpdate>>,
        ) -> Self {
            self.service_updates = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeServiceUpdatesOutput`](crate::output::DescribeServiceUpdatesOutput)
        pub fn build(self) -> crate::output::DescribeServiceUpdatesOutput {
            crate::output::DescribeServiceUpdatesOutput {
                next_token: self.next_token,
                service_updates: self.service_updates,
            }
        }
    }
}
impl DescribeServiceUpdatesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeServiceUpdatesOutput`](crate::output::DescribeServiceUpdatesOutput)
    pub fn builder() -> crate::output::describe_service_updates_output::Builder {
        crate::output::describe_service_updates_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeParametersOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>A list of parameters specific to a particular parameter group. Each element in the list contains detailed information about one parameter.</p>
    pub parameters: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
}
impl DescribeParametersOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>A list of parameters specific to a particular parameter group. Each element in the list contains detailed information about one parameter.</p>
    pub fn parameters(&self) -> std::option::Option<&[crate::model::Parameter]> {
        self.parameters.as_deref()
    }
}
impl std::fmt::Debug for DescribeParametersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeParametersOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("parameters", &self.parameters);
        formatter.finish()
    }
}
/// See [`DescribeParametersOutput`](crate::output::DescribeParametersOutput)
pub mod describe_parameters_output {
    /// A builder for [`DescribeParametersOutput`](crate::output::DescribeParametersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) parameters: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
    }
    impl Builder {
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `parameters`.
        ///
        /// To override the contents of this collection use [`set_parameters`](Self::set_parameters).
        ///
        /// <p>A list of parameters specific to a particular parameter group. Each element in the list contains detailed information about one parameter.</p>
        pub fn parameters(mut self, input: impl Into<crate::model::Parameter>) -> Self {
            let mut v = self.parameters.unwrap_or_default();
            v.push(input.into());
            self.parameters = Some(v);
            self
        }
        /// <p>A list of parameters specific to a particular parameter group. Each element in the list contains detailed information about one parameter.</p>
        pub fn set_parameters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
        ) -> Self {
            self.parameters = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeParametersOutput`](crate::output::DescribeParametersOutput)
        pub fn build(self) -> crate::output::DescribeParametersOutput {
            crate::output::DescribeParametersOutput {
                next_token: self.next_token,
                parameters: self.parameters,
            }
        }
    }
}
impl DescribeParametersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeParametersOutput`](crate::output::DescribeParametersOutput)
    pub fn builder() -> crate::output::describe_parameters_output::Builder {
        crate::output::describe_parameters_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeParameterGroupsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>A list of parameter groups. Each element in the list contains detailed information about one parameter group.</p>
    pub parameter_groups: std::option::Option<std::vec::Vec<crate::model::ParameterGroup>>,
}
impl DescribeParameterGroupsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>A list of parameter groups. Each element in the list contains detailed information about one parameter group.</p>
    pub fn parameter_groups(&self) -> std::option::Option<&[crate::model::ParameterGroup]> {
        self.parameter_groups.as_deref()
    }
}
impl std::fmt::Debug for DescribeParameterGroupsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeParameterGroupsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("parameter_groups", &self.parameter_groups);
        formatter.finish()
    }
}
/// See [`DescribeParameterGroupsOutput`](crate::output::DescribeParameterGroupsOutput)
pub mod describe_parameter_groups_output {
    /// A builder for [`DescribeParameterGroupsOutput`](crate::output::DescribeParameterGroupsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) parameter_groups:
            std::option::Option<std::vec::Vec<crate::model::ParameterGroup>>,
    }
    impl Builder {
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `parameter_groups`.
        ///
        /// To override the contents of this collection use [`set_parameter_groups`](Self::set_parameter_groups).
        ///
        /// <p>A list of parameter groups. Each element in the list contains detailed information about one parameter group.</p>
        pub fn parameter_groups(mut self, input: impl Into<crate::model::ParameterGroup>) -> Self {
            let mut v = self.parameter_groups.unwrap_or_default();
            v.push(input.into());
            self.parameter_groups = Some(v);
            self
        }
        /// <p>A list of parameter groups. Each element in the list contains detailed information about one parameter group.</p>
        pub fn set_parameter_groups(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ParameterGroup>>,
        ) -> Self {
            self.parameter_groups = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeParameterGroupsOutput`](crate::output::DescribeParameterGroupsOutput)
        pub fn build(self) -> crate::output::DescribeParameterGroupsOutput {
            crate::output::DescribeParameterGroupsOutput {
                next_token: self.next_token,
                parameter_groups: self.parameter_groups,
            }
        }
    }
}
impl DescribeParameterGroupsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeParameterGroupsOutput`](crate::output::DescribeParameterGroupsOutput)
    pub fn builder() -> crate::output::describe_parameter_groups_output::Builder {
        crate::output::describe_parameter_groups_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEventsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>A list of events. Each element in the list contains detailed information about one event.</p>
    pub events: std::option::Option<std::vec::Vec<crate::model::Event>>,
}
impl DescribeEventsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>A list of events. Each element in the list contains detailed information about one event.</p>
    pub fn events(&self) -> std::option::Option<&[crate::model::Event]> {
        self.events.as_deref()
    }
}
impl std::fmt::Debug for DescribeEventsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEventsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("events", &self.events);
        formatter.finish()
    }
}
/// See [`DescribeEventsOutput`](crate::output::DescribeEventsOutput)
pub mod describe_events_output {
    /// A builder for [`DescribeEventsOutput`](crate::output::DescribeEventsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) events: std::option::Option<std::vec::Vec<crate::model::Event>>,
    }
    impl Builder {
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `events`.
        ///
        /// To override the contents of this collection use [`set_events`](Self::set_events).
        ///
        /// <p>A list of events. Each element in the list contains detailed information about one event.</p>
        pub fn events(mut self, input: impl Into<crate::model::Event>) -> Self {
            let mut v = self.events.unwrap_or_default();
            v.push(input.into());
            self.events = Some(v);
            self
        }
        /// <p>A list of events. Each element in the list contains detailed information about one event.</p>
        pub fn set_events(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Event>>,
        ) -> Self {
            self.events = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEventsOutput`](crate::output::DescribeEventsOutput)
        pub fn build(self) -> crate::output::DescribeEventsOutput {
            crate::output::DescribeEventsOutput {
                next_token: self.next_token,
                events: self.events,
            }
        }
    }
}
impl DescribeEventsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEventsOutput`](crate::output::DescribeEventsOutput)
    pub fn builder() -> crate::output::describe_events_output::Builder {
        crate::output::describe_events_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEngineVersionsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>A list of engine version details. Each element in the list contains detailed information about one engine version.</p>
    pub engine_versions: std::option::Option<std::vec::Vec<crate::model::EngineVersionInfo>>,
}
impl DescribeEngineVersionsOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>A list of engine version details. Each element in the list contains detailed information about one engine version.</p>
    pub fn engine_versions(&self) -> std::option::Option<&[crate::model::EngineVersionInfo]> {
        self.engine_versions.as_deref()
    }
}
impl std::fmt::Debug for DescribeEngineVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEngineVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("engine_versions", &self.engine_versions);
        formatter.finish()
    }
}
/// See [`DescribeEngineVersionsOutput`](crate::output::DescribeEngineVersionsOutput)
pub mod describe_engine_versions_output {
    /// A builder for [`DescribeEngineVersionsOutput`](crate::output::DescribeEngineVersionsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) engine_versions:
            std::option::Option<std::vec::Vec<crate::model::EngineVersionInfo>>,
    }
    impl Builder {
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `engine_versions`.
        ///
        /// To override the contents of this collection use [`set_engine_versions`](Self::set_engine_versions).
        ///
        /// <p>A list of engine version details. Each element in the list contains detailed information about one engine version.</p>
        pub fn engine_versions(
            mut self,
            input: impl Into<crate::model::EngineVersionInfo>,
        ) -> Self {
            let mut v = self.engine_versions.unwrap_or_default();
            v.push(input.into());
            self.engine_versions = Some(v);
            self
        }
        /// <p>A list of engine version details. Each element in the list contains detailed information about one engine version.</p>
        pub fn set_engine_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EngineVersionInfo>>,
        ) -> Self {
            self.engine_versions = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEngineVersionsOutput`](crate::output::DescribeEngineVersionsOutput)
        pub fn build(self) -> crate::output::DescribeEngineVersionsOutput {
            crate::output::DescribeEngineVersionsOutput {
                next_token: self.next_token,
                engine_versions: self.engine_versions,
            }
        }
    }
}
impl DescribeEngineVersionsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEngineVersionsOutput`](crate::output::DescribeEngineVersionsOutput)
    pub fn builder() -> crate::output::describe_engine_versions_output::Builder {
        crate::output::describe_engine_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeClustersOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>A list of clusters</p>
    pub clusters: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
}
impl DescribeClustersOutput {
    /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>A list of clusters</p>
    pub fn clusters(&self) -> std::option::Option<&[crate::model::Cluster]> {
        self.clusters.as_deref()
    }
}
impl std::fmt::Debug for DescribeClustersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeClustersOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("clusters", &self.clusters);
        formatter.finish()
    }
}
/// See [`DescribeClustersOutput`](crate::output::DescribeClustersOutput)
pub mod describe_clusters_output {
    /// A builder for [`DescribeClustersOutput`](crate::output::DescribeClustersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) clusters: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
    }
    impl Builder {
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional argument to pass in case the total number of records exceeds the value of MaxResults. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `clusters`.
        ///
        /// To override the contents of this collection use [`set_clusters`](Self::set_clusters).
        ///
        /// <p>A list of clusters</p>
        pub fn clusters(mut self, input: impl Into<crate::model::Cluster>) -> Self {
            let mut v = self.clusters.unwrap_or_default();
            v.push(input.into());
            self.clusters = Some(v);
            self
        }
        /// <p>A list of clusters</p>
        pub fn set_clusters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
        ) -> Self {
            self.clusters = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeClustersOutput`](crate::output::DescribeClustersOutput)
        pub fn build(self) -> crate::output::DescribeClustersOutput {
            crate::output::DescribeClustersOutput {
                next_token: self.next_token,
                clusters: self.clusters,
            }
        }
    }
}
impl DescribeClustersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeClustersOutput`](crate::output::DescribeClustersOutput)
    pub fn builder() -> crate::output::describe_clusters_output::Builder {
        crate::output::describe_clusters_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAcLsOutput {
    /// <p>The list of ACLs</p>
    pub ac_ls: std::option::Option<std::vec::Vec<crate::model::Acl>>,
    /// <p>If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeAcLsOutput {
    /// <p>The list of ACLs</p>
    pub fn ac_ls(&self) -> std::option::Option<&[crate::model::Acl]> {
        self.ac_ls.as_deref()
    }
    /// <p>If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeAcLsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAcLsOutput");
        formatter.field("ac_ls", &self.ac_ls);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeAcLsOutput`](crate::output::DescribeAcLsOutput)
pub mod describe_ac_ls_output {
    /// A builder for [`DescribeAcLsOutput`](crate::output::DescribeAcLsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) ac_ls: std::option::Option<std::vec::Vec<crate::model::Acl>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `ac_ls`.
        ///
        /// To override the contents of this collection use [`set_ac_ls`](Self::set_ac_ls).
        ///
        /// <p>The list of ACLs</p>
        pub fn ac_ls(mut self, input: impl Into<crate::model::Acl>) -> Self {
            let mut v = self.ac_ls.unwrap_or_default();
            v.push(input.into());
            self.ac_ls = Some(v);
            self
        }
        /// <p>The list of ACLs</p>
        pub fn set_ac_ls(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Acl>>,
        ) -> Self {
            self.ac_ls = input;
            self
        }
        /// <p>If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAcLsOutput`](crate::output::DescribeAcLsOutput)
        pub fn build(self) -> crate::output::DescribeAcLsOutput {
            crate::output::DescribeAcLsOutput {
                ac_ls: self.ac_ls,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeAcLsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAcLsOutput`](crate::output::DescribeAcLsOutput)
    pub fn builder() -> crate::output::describe_ac_ls_output::Builder {
        crate::output::describe_ac_ls_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteUserOutput {
    /// <p>The user object that has been deleted.</p>
    pub user: std::option::Option<crate::model::User>,
}
impl DeleteUserOutput {
    /// <p>The user object that has been deleted.</p>
    pub fn user(&self) -> std::option::Option<&crate::model::User> {
        self.user.as_ref()
    }
}
impl std::fmt::Debug for DeleteUserOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteUserOutput");
        formatter.field("user", &self.user);
        formatter.finish()
    }
}
/// See [`DeleteUserOutput`](crate::output::DeleteUserOutput)
pub mod delete_user_output {
    /// A builder for [`DeleteUserOutput`](crate::output::DeleteUserOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) user: std::option::Option<crate::model::User>,
    }
    impl Builder {
        /// <p>The user object that has been deleted.</p>
        pub fn user(mut self, input: crate::model::User) -> Self {
            self.user = Some(input);
            self
        }
        /// <p>The user object that has been deleted.</p>
        pub fn set_user(mut self, input: std::option::Option<crate::model::User>) -> Self {
            self.user = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteUserOutput`](crate::output::DeleteUserOutput)
        pub fn build(self) -> crate::output::DeleteUserOutput {
            crate::output::DeleteUserOutput { user: self.user }
        }
    }
}
impl DeleteUserOutput {
    /// Creates a new builder-style object to manufacture [`DeleteUserOutput`](crate::output::DeleteUserOutput)
    pub fn builder() -> crate::output::delete_user_output::Builder {
        crate::output::delete_user_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteSubnetGroupOutput {
    /// <p>The subnet group object that has been deleted.</p>
    pub subnet_group: std::option::Option<crate::model::SubnetGroup>,
}
impl DeleteSubnetGroupOutput {
    /// <p>The subnet group object that has been deleted.</p>
    pub fn subnet_group(&self) -> std::option::Option<&crate::model::SubnetGroup> {
        self.subnet_group.as_ref()
    }
}
impl std::fmt::Debug for DeleteSubnetGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteSubnetGroupOutput");
        formatter.field("subnet_group", &self.subnet_group);
        formatter.finish()
    }
}
/// See [`DeleteSubnetGroupOutput`](crate::output::DeleteSubnetGroupOutput)
pub mod delete_subnet_group_output {
    /// A builder for [`DeleteSubnetGroupOutput`](crate::output::DeleteSubnetGroupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) subnet_group: std::option::Option<crate::model::SubnetGroup>,
    }
    impl Builder {
        /// <p>The subnet group object that has been deleted.</p>
        pub fn subnet_group(mut self, input: crate::model::SubnetGroup) -> Self {
            self.subnet_group = Some(input);
            self
        }
        /// <p>The subnet group object that has been deleted.</p>
        pub fn set_subnet_group(
            mut self,
            input: std::option::Option<crate::model::SubnetGroup>,
        ) -> Self {
            self.subnet_group = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteSubnetGroupOutput`](crate::output::DeleteSubnetGroupOutput)
        pub fn build(self) -> crate::output::DeleteSubnetGroupOutput {
            crate::output::DeleteSubnetGroupOutput {
                subnet_group: self.subnet_group,
            }
        }
    }
}
impl DeleteSubnetGroupOutput {
    /// Creates a new builder-style object to manufacture [`DeleteSubnetGroupOutput`](crate::output::DeleteSubnetGroupOutput)
    pub fn builder() -> crate::output::delete_subnet_group_output::Builder {
        crate::output::delete_subnet_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteSnapshotOutput {
    /// <p>The snapshot object that has been deleted.</p>
    pub snapshot: std::option::Option<crate::model::Snapshot>,
}
impl DeleteSnapshotOutput {
    /// <p>The snapshot object that has been deleted.</p>
    pub fn snapshot(&self) -> std::option::Option<&crate::model::Snapshot> {
        self.snapshot.as_ref()
    }
}
impl std::fmt::Debug for DeleteSnapshotOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteSnapshotOutput");
        formatter.field("snapshot", &self.snapshot);
        formatter.finish()
    }
}
/// See [`DeleteSnapshotOutput`](crate::output::DeleteSnapshotOutput)
pub mod delete_snapshot_output {
    /// A builder for [`DeleteSnapshotOutput`](crate::output::DeleteSnapshotOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) snapshot: std::option::Option<crate::model::Snapshot>,
    }
    impl Builder {
        /// <p>The snapshot object that has been deleted.</p>
        pub fn snapshot(mut self, input: crate::model::Snapshot) -> Self {
            self.snapshot = Some(input);
            self
        }
        /// <p>The snapshot object that has been deleted.</p>
        pub fn set_snapshot(mut self, input: std::option::Option<crate::model::Snapshot>) -> Self {
            self.snapshot = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteSnapshotOutput`](crate::output::DeleteSnapshotOutput)
        pub fn build(self) -> crate::output::DeleteSnapshotOutput {
            crate::output::DeleteSnapshotOutput {
                snapshot: self.snapshot,
            }
        }
    }
}
impl DeleteSnapshotOutput {
    /// Creates a new builder-style object to manufacture [`DeleteSnapshotOutput`](crate::output::DeleteSnapshotOutput)
    pub fn builder() -> crate::output::delete_snapshot_output::Builder {
        crate::output::delete_snapshot_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteParameterGroupOutput {
    /// <p>The parameter group that has been deleted.</p>
    pub parameter_group: std::option::Option<crate::model::ParameterGroup>,
}
impl DeleteParameterGroupOutput {
    /// <p>The parameter group that has been deleted.</p>
    pub fn parameter_group(&self) -> std::option::Option<&crate::model::ParameterGroup> {
        self.parameter_group.as_ref()
    }
}
impl std::fmt::Debug for DeleteParameterGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteParameterGroupOutput");
        formatter.field("parameter_group", &self.parameter_group);
        formatter.finish()
    }
}
/// See [`DeleteParameterGroupOutput`](crate::output::DeleteParameterGroupOutput)
pub mod delete_parameter_group_output {
    /// A builder for [`DeleteParameterGroupOutput`](crate::output::DeleteParameterGroupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) parameter_group: std::option::Option<crate::model::ParameterGroup>,
    }
    impl Builder {
        /// <p>The parameter group that has been deleted.</p>
        pub fn parameter_group(mut self, input: crate::model::ParameterGroup) -> Self {
            self.parameter_group = Some(input);
            self
        }
        /// <p>The parameter group that has been deleted.</p>
        pub fn set_parameter_group(
            mut self,
            input: std::option::Option<crate::model::ParameterGroup>,
        ) -> Self {
            self.parameter_group = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteParameterGroupOutput`](crate::output::DeleteParameterGroupOutput)
        pub fn build(self) -> crate::output::DeleteParameterGroupOutput {
            crate::output::DeleteParameterGroupOutput {
                parameter_group: self.parameter_group,
            }
        }
    }
}
impl DeleteParameterGroupOutput {
    /// Creates a new builder-style object to manufacture [`DeleteParameterGroupOutput`](crate::output::DeleteParameterGroupOutput)
    pub fn builder() -> crate::output::delete_parameter_group_output::Builder {
        crate::output::delete_parameter_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteClusterOutput {
    /// <p>The cluster object that has been deleted</p>
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl DeleteClusterOutput {
    /// <p>The cluster object that has been deleted</p>
    pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
        self.cluster.as_ref()
    }
}
impl std::fmt::Debug for DeleteClusterOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteClusterOutput");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}
/// See [`DeleteClusterOutput`](crate::output::DeleteClusterOutput)
pub mod delete_cluster_output {
    /// A builder for [`DeleteClusterOutput`](crate::output::DeleteClusterOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster: std::option::Option<crate::model::Cluster>,
    }
    impl Builder {
        /// <p>The cluster object that has been deleted</p>
        pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
            self.cluster = Some(input);
            self
        }
        /// <p>The cluster object that has been deleted</p>
        pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
            self.cluster = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteClusterOutput`](crate::output::DeleteClusterOutput)
        pub fn build(self) -> crate::output::DeleteClusterOutput {
            crate::output::DeleteClusterOutput {
                cluster: self.cluster,
            }
        }
    }
}
impl DeleteClusterOutput {
    /// Creates a new builder-style object to manufacture [`DeleteClusterOutput`](crate::output::DeleteClusterOutput)
    pub fn builder() -> crate::output::delete_cluster_output::Builder {
        crate::output::delete_cluster_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteAclOutput {
    /// <p>The Access Control List object that has been deleted.</p>
    pub acl: std::option::Option<crate::model::Acl>,
}
impl DeleteAclOutput {
    /// <p>The Access Control List object that has been deleted.</p>
    pub fn acl(&self) -> std::option::Option<&crate::model::Acl> {
        self.acl.as_ref()
    }
}
impl std::fmt::Debug for DeleteAclOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteAclOutput");
        formatter.field("acl", &self.acl);
        formatter.finish()
    }
}
/// See [`DeleteAclOutput`](crate::output::DeleteAclOutput)
pub mod delete_acl_output {
    /// A builder for [`DeleteAclOutput`](crate::output::DeleteAclOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) acl: std::option::Option<crate::model::Acl>,
    }
    impl Builder {
        /// <p>The Access Control List object that has been deleted.</p>
        pub fn acl(mut self, input: crate::model::Acl) -> Self {
            self.acl = Some(input);
            self
        }
        /// <p>The Access Control List object that has been deleted.</p>
        pub fn set_acl(mut self, input: std::option::Option<crate::model::Acl>) -> Self {
            self.acl = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteAclOutput`](crate::output::DeleteAclOutput)
        pub fn build(self) -> crate::output::DeleteAclOutput {
            crate::output::DeleteAclOutput { acl: self.acl }
        }
    }
}
impl DeleteAclOutput {
    /// Creates a new builder-style object to manufacture [`DeleteAclOutput`](crate::output::DeleteAclOutput)
    pub fn builder() -> crate::output::delete_acl_output::Builder {
        crate::output::delete_acl_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateUserOutput {
    /// <p>The newly-created user.</p>
    pub user: std::option::Option<crate::model::User>,
}
impl CreateUserOutput {
    /// <p>The newly-created user.</p>
    pub fn user(&self) -> std::option::Option<&crate::model::User> {
        self.user.as_ref()
    }
}
impl std::fmt::Debug for CreateUserOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateUserOutput");
        formatter.field("user", &self.user);
        formatter.finish()
    }
}
/// See [`CreateUserOutput`](crate::output::CreateUserOutput)
pub mod create_user_output {
    /// A builder for [`CreateUserOutput`](crate::output::CreateUserOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) user: std::option::Option<crate::model::User>,
    }
    impl Builder {
        /// <p>The newly-created user.</p>
        pub fn user(mut self, input: crate::model::User) -> Self {
            self.user = Some(input);
            self
        }
        /// <p>The newly-created user.</p>
        pub fn set_user(mut self, input: std::option::Option<crate::model::User>) -> Self {
            self.user = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateUserOutput`](crate::output::CreateUserOutput)
        pub fn build(self) -> crate::output::CreateUserOutput {
            crate::output::CreateUserOutput { user: self.user }
        }
    }
}
impl CreateUserOutput {
    /// Creates a new builder-style object to manufacture [`CreateUserOutput`](crate::output::CreateUserOutput)
    pub fn builder() -> crate::output::create_user_output::Builder {
        crate::output::create_user_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateSubnetGroupOutput {
    /// <p>The newly-created subnet group</p>
    pub subnet_group: std::option::Option<crate::model::SubnetGroup>,
}
impl CreateSubnetGroupOutput {
    /// <p>The newly-created subnet group</p>
    pub fn subnet_group(&self) -> std::option::Option<&crate::model::SubnetGroup> {
        self.subnet_group.as_ref()
    }
}
impl std::fmt::Debug for CreateSubnetGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateSubnetGroupOutput");
        formatter.field("subnet_group", &self.subnet_group);
        formatter.finish()
    }
}
/// See [`CreateSubnetGroupOutput`](crate::output::CreateSubnetGroupOutput)
pub mod create_subnet_group_output {
    /// A builder for [`CreateSubnetGroupOutput`](crate::output::CreateSubnetGroupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) subnet_group: std::option::Option<crate::model::SubnetGroup>,
    }
    impl Builder {
        /// <p>The newly-created subnet group</p>
        pub fn subnet_group(mut self, input: crate::model::SubnetGroup) -> Self {
            self.subnet_group = Some(input);
            self
        }
        /// <p>The newly-created subnet group</p>
        pub fn set_subnet_group(
            mut self,
            input: std::option::Option<crate::model::SubnetGroup>,
        ) -> Self {
            self.subnet_group = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateSubnetGroupOutput`](crate::output::CreateSubnetGroupOutput)
        pub fn build(self) -> crate::output::CreateSubnetGroupOutput {
            crate::output::CreateSubnetGroupOutput {
                subnet_group: self.subnet_group,
            }
        }
    }
}
impl CreateSubnetGroupOutput {
    /// Creates a new builder-style object to manufacture [`CreateSubnetGroupOutput`](crate::output::CreateSubnetGroupOutput)
    pub fn builder() -> crate::output::create_subnet_group_output::Builder {
        crate::output::create_subnet_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateSnapshotOutput {
    /// <p>The newly-created snapshot.</p>
    pub snapshot: std::option::Option<crate::model::Snapshot>,
}
impl CreateSnapshotOutput {
    /// <p>The newly-created snapshot.</p>
    pub fn snapshot(&self) -> std::option::Option<&crate::model::Snapshot> {
        self.snapshot.as_ref()
    }
}
impl std::fmt::Debug for CreateSnapshotOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateSnapshotOutput");
        formatter.field("snapshot", &self.snapshot);
        formatter.finish()
    }
}
/// See [`CreateSnapshotOutput`](crate::output::CreateSnapshotOutput)
pub mod create_snapshot_output {
    /// A builder for [`CreateSnapshotOutput`](crate::output::CreateSnapshotOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) snapshot: std::option::Option<crate::model::Snapshot>,
    }
    impl Builder {
        /// <p>The newly-created snapshot.</p>
        pub fn snapshot(mut self, input: crate::model::Snapshot) -> Self {
            self.snapshot = Some(input);
            self
        }
        /// <p>The newly-created snapshot.</p>
        pub fn set_snapshot(mut self, input: std::option::Option<crate::model::Snapshot>) -> Self {
            self.snapshot = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateSnapshotOutput`](crate::output::CreateSnapshotOutput)
        pub fn build(self) -> crate::output::CreateSnapshotOutput {
            crate::output::CreateSnapshotOutput {
                snapshot: self.snapshot,
            }
        }
    }
}
impl CreateSnapshotOutput {
    /// Creates a new builder-style object to manufacture [`CreateSnapshotOutput`](crate::output::CreateSnapshotOutput)
    pub fn builder() -> crate::output::create_snapshot_output::Builder {
        crate::output::create_snapshot_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateParameterGroupOutput {
    /// <p>The newly-created parameter group.</p>
    pub parameter_group: std::option::Option<crate::model::ParameterGroup>,
}
impl CreateParameterGroupOutput {
    /// <p>The newly-created parameter group.</p>
    pub fn parameter_group(&self) -> std::option::Option<&crate::model::ParameterGroup> {
        self.parameter_group.as_ref()
    }
}
impl std::fmt::Debug for CreateParameterGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateParameterGroupOutput");
        formatter.field("parameter_group", &self.parameter_group);
        formatter.finish()
    }
}
/// See [`CreateParameterGroupOutput`](crate::output::CreateParameterGroupOutput)
pub mod create_parameter_group_output {
    /// A builder for [`CreateParameterGroupOutput`](crate::output::CreateParameterGroupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) parameter_group: std::option::Option<crate::model::ParameterGroup>,
    }
    impl Builder {
        /// <p>The newly-created parameter group.</p>
        pub fn parameter_group(mut self, input: crate::model::ParameterGroup) -> Self {
            self.parameter_group = Some(input);
            self
        }
        /// <p>The newly-created parameter group.</p>
        pub fn set_parameter_group(
            mut self,
            input: std::option::Option<crate::model::ParameterGroup>,
        ) -> Self {
            self.parameter_group = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateParameterGroupOutput`](crate::output::CreateParameterGroupOutput)
        pub fn build(self) -> crate::output::CreateParameterGroupOutput {
            crate::output::CreateParameterGroupOutput {
                parameter_group: self.parameter_group,
            }
        }
    }
}
impl CreateParameterGroupOutput {
    /// Creates a new builder-style object to manufacture [`CreateParameterGroupOutput`](crate::output::CreateParameterGroupOutput)
    pub fn builder() -> crate::output::create_parameter_group_output::Builder {
        crate::output::create_parameter_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateClusterOutput {
    /// <p>The newly-created cluster.</p>
    pub cluster: std::option::Option<crate::model::Cluster>,
}
impl CreateClusterOutput {
    /// <p>The newly-created cluster.</p>
    pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
        self.cluster.as_ref()
    }
}
impl std::fmt::Debug for CreateClusterOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateClusterOutput");
        formatter.field("cluster", &self.cluster);
        formatter.finish()
    }
}
/// See [`CreateClusterOutput`](crate::output::CreateClusterOutput)
pub mod create_cluster_output {
    /// A builder for [`CreateClusterOutput`](crate::output::CreateClusterOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster: std::option::Option<crate::model::Cluster>,
    }
    impl Builder {
        /// <p>The newly-created cluster.</p>
        pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
            self.cluster = Some(input);
            self
        }
        /// <p>The newly-created cluster.</p>
        pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
            self.cluster = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateClusterOutput`](crate::output::CreateClusterOutput)
        pub fn build(self) -> crate::output::CreateClusterOutput {
            crate::output::CreateClusterOutput {
                cluster: self.cluster,
            }
        }
    }
}
impl CreateClusterOutput {
    /// Creates a new builder-style object to manufacture [`CreateClusterOutput`](crate::output::CreateClusterOutput)
    pub fn builder() -> crate::output::create_cluster_output::Builder {
        crate::output::create_cluster_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateAclOutput {
    /// <p>The newly-created Access Control List.</p>
    pub acl: std::option::Option<crate::model::Acl>,
}
impl CreateAclOutput {
    /// <p>The newly-created Access Control List.</p>
    pub fn acl(&self) -> std::option::Option<&crate::model::Acl> {
        self.acl.as_ref()
    }
}
impl std::fmt::Debug for CreateAclOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateAclOutput");
        formatter.field("acl", &self.acl);
        formatter.finish()
    }
}
/// See [`CreateAclOutput`](crate::output::CreateAclOutput)
pub mod create_acl_output {
    /// A builder for [`CreateAclOutput`](crate::output::CreateAclOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) acl: std::option::Option<crate::model::Acl>,
    }
    impl Builder {
        /// <p>The newly-created Access Control List.</p>
        pub fn acl(mut self, input: crate::model::Acl) -> Self {
            self.acl = Some(input);
            self
        }
        /// <p>The newly-created Access Control List.</p>
        pub fn set_acl(mut self, input: std::option::Option<crate::model::Acl>) -> Self {
            self.acl = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateAclOutput`](crate::output::CreateAclOutput)
        pub fn build(self) -> crate::output::CreateAclOutput {
            crate::output::CreateAclOutput { acl: self.acl }
        }
    }
}
impl CreateAclOutput {
    /// Creates a new builder-style object to manufacture [`CreateAclOutput`](crate::output::CreateAclOutput)
    pub fn builder() -> crate::output::create_acl_output::Builder {
        crate::output::create_acl_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CopySnapshotOutput {
    /// <p>Represents a copy of an entire cluster as of the time when the snapshot was taken.</p>
    pub snapshot: std::option::Option<crate::model::Snapshot>,
}
impl CopySnapshotOutput {
    /// <p>Represents a copy of an entire cluster as of the time when the snapshot was taken.</p>
    pub fn snapshot(&self) -> std::option::Option<&crate::model::Snapshot> {
        self.snapshot.as_ref()
    }
}
impl std::fmt::Debug for CopySnapshotOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CopySnapshotOutput");
        formatter.field("snapshot", &self.snapshot);
        formatter.finish()
    }
}
/// See [`CopySnapshotOutput`](crate::output::CopySnapshotOutput)
pub mod copy_snapshot_output {
    /// A builder for [`CopySnapshotOutput`](crate::output::CopySnapshotOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) snapshot: std::option::Option<crate::model::Snapshot>,
    }
    impl Builder {
        /// <p>Represents a copy of an entire cluster as of the time when the snapshot was taken.</p>
        pub fn snapshot(mut self, input: crate::model::Snapshot) -> Self {
            self.snapshot = Some(input);
            self
        }
        /// <p>Represents a copy of an entire cluster as of the time when the snapshot was taken.</p>
        pub fn set_snapshot(mut self, input: std::option::Option<crate::model::Snapshot>) -> Self {
            self.snapshot = input;
            self
        }
        /// Consumes the builder and constructs a [`CopySnapshotOutput`](crate::output::CopySnapshotOutput)
        pub fn build(self) -> crate::output::CopySnapshotOutput {
            crate::output::CopySnapshotOutput {
                snapshot: self.snapshot,
            }
        }
    }
}
impl CopySnapshotOutput {
    /// Creates a new builder-style object to manufacture [`CopySnapshotOutput`](crate::output::CopySnapshotOutput)
    pub fn builder() -> crate::output::copy_snapshot_output::Builder {
        crate::output::copy_snapshot_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BatchUpdateClusterOutput {
    /// <p>The list of clusters that have been updated.</p>
    pub processed_clusters: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
    /// <p>The list of clusters where updates have not been applied.</p>
    pub unprocessed_clusters: std::option::Option<std::vec::Vec<crate::model::UnprocessedCluster>>,
}
impl BatchUpdateClusterOutput {
    /// <p>The list of clusters that have been updated.</p>
    pub fn processed_clusters(&self) -> std::option::Option<&[crate::model::Cluster]> {
        self.processed_clusters.as_deref()
    }
    /// <p>The list of clusters where updates have not been applied.</p>
    pub fn unprocessed_clusters(&self) -> std::option::Option<&[crate::model::UnprocessedCluster]> {
        self.unprocessed_clusters.as_deref()
    }
}
impl std::fmt::Debug for BatchUpdateClusterOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("BatchUpdateClusterOutput");
        formatter.field("processed_clusters", &self.processed_clusters);
        formatter.field("unprocessed_clusters", &self.unprocessed_clusters);
        formatter.finish()
    }
}
/// See [`BatchUpdateClusterOutput`](crate::output::BatchUpdateClusterOutput)
pub mod batch_update_cluster_output {
    /// A builder for [`BatchUpdateClusterOutput`](crate::output::BatchUpdateClusterOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) processed_clusters: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
        pub(crate) unprocessed_clusters:
            std::option::Option<std::vec::Vec<crate::model::UnprocessedCluster>>,
    }
    impl Builder {
        /// Appends an item to `processed_clusters`.
        ///
        /// To override the contents of this collection use [`set_processed_clusters`](Self::set_processed_clusters).
        ///
        /// <p>The list of clusters that have been updated.</p>
        pub fn processed_clusters(mut self, input: impl Into<crate::model::Cluster>) -> Self {
            let mut v = self.processed_clusters.unwrap_or_default();
            v.push(input.into());
            self.processed_clusters = Some(v);
            self
        }
        /// <p>The list of clusters that have been updated.</p>
        pub fn set_processed_clusters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
        ) -> Self {
            self.processed_clusters = input;
            self
        }
        /// Appends an item to `unprocessed_clusters`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_clusters`](Self::set_unprocessed_clusters).
        ///
        /// <p>The list of clusters where updates have not been applied.</p>
        pub fn unprocessed_clusters(
            mut self,
            input: impl Into<crate::model::UnprocessedCluster>,
        ) -> Self {
            let mut v = self.unprocessed_clusters.unwrap_or_default();
            v.push(input.into());
            self.unprocessed_clusters = Some(v);
            self
        }
        /// <p>The list of clusters where updates have not been applied.</p>
        pub fn set_unprocessed_clusters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::UnprocessedCluster>>,
        ) -> Self {
            self.unprocessed_clusters = input;
            self
        }
        /// Consumes the builder and constructs a [`BatchUpdateClusterOutput`](crate::output::BatchUpdateClusterOutput)
        pub fn build(self) -> crate::output::BatchUpdateClusterOutput {
            crate::output::BatchUpdateClusterOutput {
                processed_clusters: self.processed_clusters,
                unprocessed_clusters: self.unprocessed_clusters,
            }
        }
    }
}
impl BatchUpdateClusterOutput {
    /// Creates a new builder-style object to manufacture [`BatchUpdateClusterOutput`](crate::output::BatchUpdateClusterOutput)
    pub fn builder() -> crate::output::batch_update_cluster_output::Builder {
        crate::output::batch_update_cluster_output::Builder::default()
    }
}