aws-sdk-managedblockchain 0.0.23-alpha

// 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 VoteOnProposalOutput {}
impl std::fmt::Debug for VoteOnProposalOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("VoteOnProposalOutput");
        formatter.finish()
    }
}
/// See [`VoteOnProposalOutput`](crate::output::VoteOnProposalOutput)
pub mod vote_on_proposal_output {
    /// A builder for [`VoteOnProposalOutput`](crate::output::VoteOnProposalOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`VoteOnProposalOutput`](crate::output::VoteOnProposalOutput)
        pub fn build(self) -> crate::output::VoteOnProposalOutput {
            crate::output::VoteOnProposalOutput {}
        }
    }
}
impl VoteOnProposalOutput {
    /// Creates a new builder-style object to manufacture [`VoteOnProposalOutput`](crate::output::VoteOnProposalOutput)
    pub fn builder() -> crate::output::vote_on_proposal_output::Builder {
        crate::output::vote_on_proposal_output::Builder::default()
    }
}

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UntagResourceOutput {}
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.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 {}
    impl Builder {
        /// Consumes the builder and constructs a [`UntagResourceOutput`](crate::output::UntagResourceOutput)
        pub fn build(self) -> crate::output::UntagResourceOutput {
            crate::output::UntagResourceOutput {}
        }
    }
}
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 {}
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.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 {}
    impl Builder {
        /// Consumes the builder and constructs a [`TagResourceOutput`](crate::output::TagResourceOutput)
        pub fn build(self) -> crate::output::TagResourceOutput {
            crate::output::TagResourceOutput {}
        }
    }
}
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 RejectInvitationOutput {}
impl std::fmt::Debug for RejectInvitationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RejectInvitationOutput");
        formatter.finish()
    }
}
/// See [`RejectInvitationOutput`](crate::output::RejectInvitationOutput)
pub mod reject_invitation_output {
    /// A builder for [`RejectInvitationOutput`](crate::output::RejectInvitationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`RejectInvitationOutput`](crate::output::RejectInvitationOutput)
        pub fn build(self) -> crate::output::RejectInvitationOutput {
            crate::output::RejectInvitationOutput {}
        }
    }
}
impl RejectInvitationOutput {
    /// Creates a new builder-style object to manufacture [`RejectInvitationOutput`](crate::output::RejectInvitationOutput)
    pub fn builder() -> crate::output::reject_invitation_output::Builder {
        crate::output::reject_invitation_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceOutput {
    /// <p>The tags assigned to the resource.</p>
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl std::fmt::Debug for ListTagsForResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsForResourceOutput");
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
pub mod list_tags_for_resource_output {
    /// A builder for [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags assigned to the resource.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.tags.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.tags = Some(hash_map);
            self
        }
        /// <p>The tags assigned to the resource.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
        pub fn build(self) -> crate::output::ListTagsForResourceOutput {
            crate::output::ListTagsForResourceOutput { tags: self.tags }
        }
    }
}
impl ListTagsForResourceOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
        crate::output::list_tags_for_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListProposalVotesOutput {
    /// <p>
    /// The list of votes.
    /// </p>
    pub proposal_votes: std::option::Option<std::vec::Vec<crate::model::VoteSummary>>,
    /// <p>
    /// The pagination token that indicates the next set of results to retrieve.
    /// </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListProposalVotesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListProposalVotesOutput");
        formatter.field("proposal_votes", &self.proposal_votes);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListProposalVotesOutput`](crate::output::ListProposalVotesOutput)
pub mod list_proposal_votes_output {
    /// A builder for [`ListProposalVotesOutput`](crate::output::ListProposalVotesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) proposal_votes: std::option::Option<std::vec::Vec<crate::model::VoteSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `proposal_votes`.
        ///
        /// To override the contents of this collection use [`set_proposal_votes`](Self::set_proposal_votes).
        ///
        /// <p>
        /// The list of votes.
        /// </p>
        pub fn proposal_votes(mut self, input: impl Into<crate::model::VoteSummary>) -> Self {
            let mut v = self.proposal_votes.unwrap_or_default();
            v.push(input.into());
            self.proposal_votes = Some(v);
            self
        }
        /// <p>
        /// The list of votes.
        /// </p>
        pub fn set_proposal_votes(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VoteSummary>>,
        ) -> Self {
            self.proposal_votes = input;
            self
        }
        /// <p>
        /// The pagination token that indicates the next set of results to retrieve.
        /// </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>
        /// The pagination token that indicates the next set of results to retrieve.
        /// </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 [`ListProposalVotesOutput`](crate::output::ListProposalVotesOutput)
        pub fn build(self) -> crate::output::ListProposalVotesOutput {
            crate::output::ListProposalVotesOutput {
                proposal_votes: self.proposal_votes,
                next_token: self.next_token,
            }
        }
    }
}
impl ListProposalVotesOutput {
    /// Creates a new builder-style object to manufacture [`ListProposalVotesOutput`](crate::output::ListProposalVotesOutput)
    pub fn builder() -> crate::output::list_proposal_votes_output::Builder {
        crate::output::list_proposal_votes_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListProposalsOutput {
    /// <p>The summary of each proposal made on the network.</p>
    pub proposals: std::option::Option<std::vec::Vec<crate::model::ProposalSummary>>,
    /// <p>The pagination token that indicates the next set of results to retrieve.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListProposalsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListProposalsOutput");
        formatter.field("proposals", &self.proposals);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListProposalsOutput`](crate::output::ListProposalsOutput)
pub mod list_proposals_output {
    /// A builder for [`ListProposalsOutput`](crate::output::ListProposalsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) proposals: std::option::Option<std::vec::Vec<crate::model::ProposalSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `proposals`.
        ///
        /// To override the contents of this collection use [`set_proposals`](Self::set_proposals).
        ///
        /// <p>The summary of each proposal made on the network.</p>
        pub fn proposals(mut self, input: impl Into<crate::model::ProposalSummary>) -> Self {
            let mut v = self.proposals.unwrap_or_default();
            v.push(input.into());
            self.proposals = Some(v);
            self
        }
        /// <p>The summary of each proposal made on the network.</p>
        pub fn set_proposals(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ProposalSummary>>,
        ) -> Self {
            self.proposals = input;
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</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 [`ListProposalsOutput`](crate::output::ListProposalsOutput)
        pub fn build(self) -> crate::output::ListProposalsOutput {
            crate::output::ListProposalsOutput {
                proposals: self.proposals,
                next_token: self.next_token,
            }
        }
    }
}
impl ListProposalsOutput {
    /// Creates a new builder-style object to manufacture [`ListProposalsOutput`](crate::output::ListProposalsOutput)
    pub fn builder() -> crate::output::list_proposals_output::Builder {
        crate::output::list_proposals_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListNodesOutput {
    /// <p>An array of <code>NodeSummary</code> objects that contain configuration properties for each node.</p>
    pub nodes: std::option::Option<std::vec::Vec<crate::model::NodeSummary>>,
    /// <p>The pagination token that indicates the next set of results to retrieve.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListNodesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListNodesOutput");
        formatter.field("nodes", &self.nodes);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListNodesOutput`](crate::output::ListNodesOutput)
pub mod list_nodes_output {
    /// A builder for [`ListNodesOutput`](crate::output::ListNodesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) nodes: std::option::Option<std::vec::Vec<crate::model::NodeSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `nodes`.
        ///
        /// To override the contents of this collection use [`set_nodes`](Self::set_nodes).
        ///
        /// <p>An array of <code>NodeSummary</code> objects that contain configuration properties for each node.</p>
        pub fn nodes(mut self, input: impl Into<crate::model::NodeSummary>) -> Self {
            let mut v = self.nodes.unwrap_or_default();
            v.push(input.into());
            self.nodes = Some(v);
            self
        }
        /// <p>An array of <code>NodeSummary</code> objects that contain configuration properties for each node.</p>
        pub fn set_nodes(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::NodeSummary>>,
        ) -> Self {
            self.nodes = input;
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</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 [`ListNodesOutput`](crate::output::ListNodesOutput)
        pub fn build(self) -> crate::output::ListNodesOutput {
            crate::output::ListNodesOutput {
                nodes: self.nodes,
                next_token: self.next_token,
            }
        }
    }
}
impl ListNodesOutput {
    /// Creates a new builder-style object to manufacture [`ListNodesOutput`](crate::output::ListNodesOutput)
    pub fn builder() -> crate::output::list_nodes_output::Builder {
        crate::output::list_nodes_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListNetworksOutput {
    /// <p>An array of <code>NetworkSummary</code> objects that contain configuration properties for each network.</p>
    pub networks: std::option::Option<std::vec::Vec<crate::model::NetworkSummary>>,
    /// <p>The pagination token that indicates the next set of results to retrieve.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListNetworksOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListNetworksOutput");
        formatter.field("networks", &self.networks);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListNetworksOutput`](crate::output::ListNetworksOutput)
pub mod list_networks_output {
    /// A builder for [`ListNetworksOutput`](crate::output::ListNetworksOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) networks: std::option::Option<std::vec::Vec<crate::model::NetworkSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `networks`.
        ///
        /// To override the contents of this collection use [`set_networks`](Self::set_networks).
        ///
        /// <p>An array of <code>NetworkSummary</code> objects that contain configuration properties for each network.</p>
        pub fn networks(mut self, input: impl Into<crate::model::NetworkSummary>) -> Self {
            let mut v = self.networks.unwrap_or_default();
            v.push(input.into());
            self.networks = Some(v);
            self
        }
        /// <p>An array of <code>NetworkSummary</code> objects that contain configuration properties for each network.</p>
        pub fn set_networks(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::NetworkSummary>>,
        ) -> Self {
            self.networks = input;
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</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 [`ListNetworksOutput`](crate::output::ListNetworksOutput)
        pub fn build(self) -> crate::output::ListNetworksOutput {
            crate::output::ListNetworksOutput {
                networks: self.networks,
                next_token: self.next_token,
            }
        }
    }
}
impl ListNetworksOutput {
    /// Creates a new builder-style object to manufacture [`ListNetworksOutput`](crate::output::ListNetworksOutput)
    pub fn builder() -> crate::output::list_networks_output::Builder {
        crate::output::list_networks_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListMembersOutput {
    /// <p>An array of <code>MemberSummary</code> objects. Each object contains details about a network member.</p>
    pub members: std::option::Option<std::vec::Vec<crate::model::MemberSummary>>,
    /// <p>The pagination token that indicates the next set of results to retrieve.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListMembersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListMembersOutput");
        formatter.field("members", &self.members);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListMembersOutput`](crate::output::ListMembersOutput)
pub mod list_members_output {
    /// A builder for [`ListMembersOutput`](crate::output::ListMembersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) members: std::option::Option<std::vec::Vec<crate::model::MemberSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `members`.
        ///
        /// To override the contents of this collection use [`set_members`](Self::set_members).
        ///
        /// <p>An array of <code>MemberSummary</code> objects. Each object contains details about a network member.</p>
        pub fn members(mut self, input: impl Into<crate::model::MemberSummary>) -> Self {
            let mut v = self.members.unwrap_or_default();
            v.push(input.into());
            self.members = Some(v);
            self
        }
        /// <p>An array of <code>MemberSummary</code> objects. Each object contains details about a network member.</p>
        pub fn set_members(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::MemberSummary>>,
        ) -> Self {
            self.members = input;
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</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 [`ListMembersOutput`](crate::output::ListMembersOutput)
        pub fn build(self) -> crate::output::ListMembersOutput {
            crate::output::ListMembersOutput {
                members: self.members,
                next_token: self.next_token,
            }
        }
    }
}
impl ListMembersOutput {
    /// Creates a new builder-style object to manufacture [`ListMembersOutput`](crate::output::ListMembersOutput)
    pub fn builder() -> crate::output::list_members_output::Builder {
        crate::output::list_members_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListInvitationsOutput {
    /// <p>The invitations for the network.</p>
    pub invitations: std::option::Option<std::vec::Vec<crate::model::Invitation>>,
    /// <p>The pagination token that indicates the next set of results to retrieve.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListInvitationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListInvitationsOutput");
        formatter.field("invitations", &self.invitations);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListInvitationsOutput`](crate::output::ListInvitationsOutput)
pub mod list_invitations_output {
    /// A builder for [`ListInvitationsOutput`](crate::output::ListInvitationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) invitations: std::option::Option<std::vec::Vec<crate::model::Invitation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `invitations`.
        ///
        /// To override the contents of this collection use [`set_invitations`](Self::set_invitations).
        ///
        /// <p>The invitations for the network.</p>
        pub fn invitations(mut self, input: impl Into<crate::model::Invitation>) -> Self {
            let mut v = self.invitations.unwrap_or_default();
            v.push(input.into());
            self.invitations = Some(v);
            self
        }
        /// <p>The invitations for the network.</p>
        pub fn set_invitations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Invitation>>,
        ) -> Self {
            self.invitations = input;
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token that indicates the next set of results to retrieve.</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 [`ListInvitationsOutput`](crate::output::ListInvitationsOutput)
        pub fn build(self) -> crate::output::ListInvitationsOutput {
            crate::output::ListInvitationsOutput {
                invitations: self.invitations,
                next_token: self.next_token,
            }
        }
    }
}
impl ListInvitationsOutput {
    /// Creates a new builder-style object to manufacture [`ListInvitationsOutput`](crate::output::ListInvitationsOutput)
    pub fn builder() -> crate::output::list_invitations_output::Builder {
        crate::output::list_invitations_output::Builder::default()
    }
}

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

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

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateNetworkOutput {
    /// <p>The unique identifier for the network.</p>
    pub network_id: std::option::Option<std::string::String>,
    /// <p>The unique identifier for the first member within the network.</p>
    pub member_id: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for CreateNetworkOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateNetworkOutput");
        formatter.field("network_id", &self.network_id);
        formatter.field("member_id", &self.member_id);
        formatter.finish()
    }
}
/// See [`CreateNetworkOutput`](crate::output::CreateNetworkOutput)
pub mod create_network_output {
    /// A builder for [`CreateNetworkOutput`](crate::output::CreateNetworkOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) network_id: std::option::Option<std::string::String>,
        pub(crate) member_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The unique identifier for the network.</p>
        pub fn network_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.network_id = Some(input.into());
            self
        }
        /// <p>The unique identifier for the network.</p>
        pub fn set_network_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.network_id = input;
            self
        }
        /// <p>The unique identifier for the first member within the network.</p>
        pub fn member_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.member_id = Some(input.into());
            self
        }
        /// <p>The unique identifier for the first member within the network.</p>
        pub fn set_member_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.member_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateNetworkOutput`](crate::output::CreateNetworkOutput)
        pub fn build(self) -> crate::output::CreateNetworkOutput {
            crate::output::CreateNetworkOutput {
                network_id: self.network_id,
                member_id: self.member_id,
            }
        }
    }
}
impl CreateNetworkOutput {
    /// Creates a new builder-style object to manufacture [`CreateNetworkOutput`](crate::output::CreateNetworkOutput)
    pub fn builder() -> crate::output::create_network_output::Builder {
        crate::output::create_network_output::Builder::default()
    }
}

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