aws-sdk-chimesdkmessaging 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateChannelReadMarkerOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The ID of the SubChannel in the response.</p>
    #[doc(hidden)]
    pub sub_channel_id: std::option::Option<std::string::String>,
}
impl UpdateChannelReadMarkerOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The ID of the SubChannel in the response.</p>
    pub fn sub_channel_id(&self) -> std::option::Option<&str> {
        self.sub_channel_id.as_deref()
    }
}
/// See [`UpdateChannelReadMarkerOutput`](crate::output::UpdateChannelReadMarkerOutput).
pub mod update_channel_read_marker_output {

    /// A builder for [`UpdateChannelReadMarkerOutput`](crate::output::UpdateChannelReadMarkerOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) sub_channel_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn sub_channel_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.sub_channel_id = Some(input.into());
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn set_sub_channel_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.sub_channel_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateChannelReadMarkerOutput`](crate::output::UpdateChannelReadMarkerOutput).
        pub fn build(self) -> crate::output::UpdateChannelReadMarkerOutput {
            crate::output::UpdateChannelReadMarkerOutput {
                channel_arn: self.channel_arn,
                sub_channel_id: self.sub_channel_id,
            }
        }
    }
}
impl UpdateChannelReadMarkerOutput {
    /// Creates a new builder-style object to manufacture [`UpdateChannelReadMarkerOutput`](crate::output::UpdateChannelReadMarkerOutput).
    pub fn builder() -> crate::output::update_channel_read_marker_output::Builder {
        crate::output::update_channel_read_marker_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateChannelMessageOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The ID string of the message being updated.</p>
    #[doc(hidden)]
    pub message_id: std::option::Option<std::string::String>,
    /// <p>The status of the message update.</p>
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::ChannelMessageStatusStructure>,
    /// <p>The ID of the SubChannel in the response.</p>
    #[doc(hidden)]
    pub sub_channel_id: std::option::Option<std::string::String>,
}
impl UpdateChannelMessageOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The ID string of the message being updated.</p>
    pub fn message_id(&self) -> std::option::Option<&str> {
        self.message_id.as_deref()
    }
    /// <p>The status of the message update.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::ChannelMessageStatusStructure> {
        self.status.as_ref()
    }
    /// <p>The ID of the SubChannel in the response.</p>
    pub fn sub_channel_id(&self) -> std::option::Option<&str> {
        self.sub_channel_id.as_deref()
    }
}
/// See [`UpdateChannelMessageOutput`](crate::output::UpdateChannelMessageOutput).
pub mod update_channel_message_output {

    /// A builder for [`UpdateChannelMessageOutput`](crate::output::UpdateChannelMessageOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) message_id: std::option::Option<std::string::String>,
        pub(crate) status: std::option::Option<crate::model::ChannelMessageStatusStructure>,
        pub(crate) sub_channel_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The ID string of the message being updated.</p>
        pub fn message_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_id = Some(input.into());
            self
        }
        /// <p>The ID string of the message being updated.</p>
        pub fn set_message_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message_id = input;
            self
        }
        /// <p>The status of the message update.</p>
        pub fn status(mut self, input: crate::model::ChannelMessageStatusStructure) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>The status of the message update.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::ChannelMessageStatusStructure>,
        ) -> Self {
            self.status = input;
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn sub_channel_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.sub_channel_id = Some(input.into());
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn set_sub_channel_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.sub_channel_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateChannelMessageOutput`](crate::output::UpdateChannelMessageOutput).
        pub fn build(self) -> crate::output::UpdateChannelMessageOutput {
            crate::output::UpdateChannelMessageOutput {
                channel_arn: self.channel_arn,
                message_id: self.message_id,
                status: self.status,
                sub_channel_id: self.sub_channel_id,
            }
        }
    }
}
impl UpdateChannelMessageOutput {
    /// Creates a new builder-style object to manufacture [`UpdateChannelMessageOutput`](crate::output::UpdateChannelMessageOutput).
    pub fn builder() -> crate::output::update_channel_message_output::Builder {
        crate::output::update_channel_message_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateChannelFlowOutput {
    /// <p>The ARN of the channel flow.</p>
    #[doc(hidden)]
    pub channel_flow_arn: std::option::Option<std::string::String>,
}
impl UpdateChannelFlowOutput {
    /// <p>The ARN of the channel flow.</p>
    pub fn channel_flow_arn(&self) -> std::option::Option<&str> {
        self.channel_flow_arn.as_deref()
    }
}
/// See [`UpdateChannelFlowOutput`](crate::output::UpdateChannelFlowOutput).
pub mod update_channel_flow_output {

    /// A builder for [`UpdateChannelFlowOutput`](crate::output::UpdateChannelFlowOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_flow_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel flow.</p>
        pub fn channel_flow_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_flow_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel flow.</p>
        pub fn set_channel_flow_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.channel_flow_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateChannelFlowOutput`](crate::output::UpdateChannelFlowOutput).
        pub fn build(self) -> crate::output::UpdateChannelFlowOutput {
            crate::output::UpdateChannelFlowOutput {
                channel_flow_arn: self.channel_flow_arn,
            }
        }
    }
}
impl UpdateChannelFlowOutput {
    /// Creates a new builder-style object to manufacture [`UpdateChannelFlowOutput`](crate::output::UpdateChannelFlowOutput).
    pub fn builder() -> crate::output::update_channel_flow_output::Builder {
        crate::output::update_channel_flow_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateChannelOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
}
impl UpdateChannelOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
}
/// See [`UpdateChannelOutput`](crate::output::UpdateChannelOutput).
pub mod update_channel_output {

    /// A builder for [`UpdateChannelOutput`](crate::output::UpdateChannelOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateChannelOutput`](crate::output::UpdateChannelOutput).
        pub fn build(self) -> crate::output::UpdateChannelOutput {
            crate::output::UpdateChannelOutput {
                channel_arn: self.channel_arn,
            }
        }
    }
}
impl UpdateChannelOutput {
    /// Creates a new builder-style object to manufacture [`UpdateChannelOutput`](crate::output::UpdateChannelOutput).
    pub fn builder() -> crate::output::update_channel_output::Builder {
        crate::output::update_channel_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UntagResourceOutput {}
/// See [`UntagResourceOutput`](crate::output::UntagResourceOutput).
pub mod untag_resource_output {

    /// A builder for [`UntagResourceOutput`](crate::output::UntagResourceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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, std::fmt::Debug)]
pub struct TagResourceOutput {}
/// See [`TagResourceOutput`](crate::output::TagResourceOutput).
pub mod tag_resource_output {

    /// A builder for [`TagResourceOutput`](crate::output::TagResourceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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, std::fmt::Debug)]
pub struct SendChannelMessageOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The ID string assigned to each message.</p>
    #[doc(hidden)]
    pub message_id: std::option::Option<std::string::String>,
    /// <p>The status of the channel message.</p>
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::ChannelMessageStatusStructure>,
    /// <p>The ID of the SubChannel in the response.</p>
    #[doc(hidden)]
    pub sub_channel_id: std::option::Option<std::string::String>,
}
impl SendChannelMessageOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The ID string assigned to each message.</p>
    pub fn message_id(&self) -> std::option::Option<&str> {
        self.message_id.as_deref()
    }
    /// <p>The status of the channel message.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::ChannelMessageStatusStructure> {
        self.status.as_ref()
    }
    /// <p>The ID of the SubChannel in the response.</p>
    pub fn sub_channel_id(&self) -> std::option::Option<&str> {
        self.sub_channel_id.as_deref()
    }
}
/// See [`SendChannelMessageOutput`](crate::output::SendChannelMessageOutput).
pub mod send_channel_message_output {

    /// A builder for [`SendChannelMessageOutput`](crate::output::SendChannelMessageOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) message_id: std::option::Option<std::string::String>,
        pub(crate) status: std::option::Option<crate::model::ChannelMessageStatusStructure>,
        pub(crate) sub_channel_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The ID string assigned to each message.</p>
        pub fn message_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_id = Some(input.into());
            self
        }
        /// <p>The ID string assigned to each message.</p>
        pub fn set_message_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message_id = input;
            self
        }
        /// <p>The status of the channel message.</p>
        pub fn status(mut self, input: crate::model::ChannelMessageStatusStructure) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>The status of the channel message.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::ChannelMessageStatusStructure>,
        ) -> Self {
            self.status = input;
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn sub_channel_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.sub_channel_id = Some(input.into());
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn set_sub_channel_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.sub_channel_id = input;
            self
        }
        /// Consumes the builder and constructs a [`SendChannelMessageOutput`](crate::output::SendChannelMessageOutput).
        pub fn build(self) -> crate::output::SendChannelMessageOutput {
            crate::output::SendChannelMessageOutput {
                channel_arn: self.channel_arn,
                message_id: self.message_id,
                status: self.status,
                sub_channel_id: self.sub_channel_id,
            }
        }
    }
}
impl SendChannelMessageOutput {
    /// Creates a new builder-style object to manufacture [`SendChannelMessageOutput`](crate::output::SendChannelMessageOutput).
    pub fn builder() -> crate::output::send_channel_message_output::Builder {
        crate::output::send_channel_message_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchChannelsOutput {
    /// <p>A list of the channels in the request.</p>
    #[doc(hidden)]
    pub channels: std::option::Option<std::vec::Vec<crate::model::ChannelSummary>>,
    /// <p>The token returned from previous API responses until the number of channels is reached.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl SearchChannelsOutput {
    /// <p>A list of the channels in the request.</p>
    pub fn channels(&self) -> std::option::Option<&[crate::model::ChannelSummary]> {
        self.channels.as_deref()
    }
    /// <p>The token returned from previous API responses until the number of channels is reached.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for SearchChannelsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchChannelsOutput");
        formatter.field("channels", &self.channels);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.finish()
    }
}
/// See [`SearchChannelsOutput`](crate::output::SearchChannelsOutput).
pub mod search_channels_output {

    /// A builder for [`SearchChannelsOutput`](crate::output::SearchChannelsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channels: std::option::Option<std::vec::Vec<crate::model::ChannelSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `channels`.
        ///
        /// To override the contents of this collection use [`set_channels`](Self::set_channels).
        ///
        /// <p>A list of the channels in the request.</p>
        pub fn channels(mut self, input: crate::model::ChannelSummary) -> Self {
            let mut v = self.channels.unwrap_or_default();
            v.push(input);
            self.channels = Some(v);
            self
        }
        /// <p>A list of the channels in the request.</p>
        pub fn set_channels(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ChannelSummary>>,
        ) -> Self {
            self.channels = input;
            self
        }
        /// <p>The token returned from previous API responses until the number of channels is reached.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token returned from previous API responses until the number of channels is reached.</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 [`SearchChannelsOutput`](crate::output::SearchChannelsOutput).
        pub fn build(self) -> crate::output::SearchChannelsOutput {
            crate::output::SearchChannelsOutput {
                channels: self.channels,
                next_token: self.next_token,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channels", &self.channels);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.finish()
        }
    }
}
impl SearchChannelsOutput {
    /// Creates a new builder-style object to manufacture [`SearchChannelsOutput`](crate::output::SearchChannelsOutput).
    pub fn builder() -> crate::output::search_channels_output::Builder {
        crate::output::search_channels_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RedactChannelMessageOutput {
    /// <p>The ARN of the channel containing the messages that you want to redact.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The ID of the message being redacted.</p>
    #[doc(hidden)]
    pub message_id: std::option::Option<std::string::String>,
    /// <p>The ID of the SubChannel in the response.</p> <note>
    /// <p>Only required when redacting messages in a SubChannel that the user belongs to.</p>
    /// </note>
    #[doc(hidden)]
    pub sub_channel_id: std::option::Option<std::string::String>,
}
impl RedactChannelMessageOutput {
    /// <p>The ARN of the channel containing the messages that you want to redact.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The ID of the message being redacted.</p>
    pub fn message_id(&self) -> std::option::Option<&str> {
        self.message_id.as_deref()
    }
    /// <p>The ID of the SubChannel in the response.</p> <note>
    /// <p>Only required when redacting messages in a SubChannel that the user belongs to.</p>
    /// </note>
    pub fn sub_channel_id(&self) -> std::option::Option<&str> {
        self.sub_channel_id.as_deref()
    }
}
/// See [`RedactChannelMessageOutput`](crate::output::RedactChannelMessageOutput).
pub mod redact_channel_message_output {

    /// A builder for [`RedactChannelMessageOutput`](crate::output::RedactChannelMessageOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) message_id: std::option::Option<std::string::String>,
        pub(crate) sub_channel_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel containing the messages that you want to redact.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel containing the messages that you want to redact.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The ID of the message being redacted.</p>
        pub fn message_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_id = Some(input.into());
            self
        }
        /// <p>The ID of the message being redacted.</p>
        pub fn set_message_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message_id = input;
            self
        }
        /// <p>The ID of the SubChannel in the response.</p> <note>
        /// <p>Only required when redacting messages in a SubChannel that the user belongs to.</p>
        /// </note>
        pub fn sub_channel_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.sub_channel_id = Some(input.into());
            self
        }
        /// <p>The ID of the SubChannel in the response.</p> <note>
        /// <p>Only required when redacting messages in a SubChannel that the user belongs to.</p>
        /// </note>
        pub fn set_sub_channel_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.sub_channel_id = input;
            self
        }
        /// Consumes the builder and constructs a [`RedactChannelMessageOutput`](crate::output::RedactChannelMessageOutput).
        pub fn build(self) -> crate::output::RedactChannelMessageOutput {
            crate::output::RedactChannelMessageOutput {
                channel_arn: self.channel_arn,
                message_id: self.message_id,
                sub_channel_id: self.sub_channel_id,
            }
        }
    }
}
impl RedactChannelMessageOutput {
    /// Creates a new builder-style object to manufacture [`RedactChannelMessageOutput`](crate::output::RedactChannelMessageOutput).
    pub fn builder() -> crate::output::redact_channel_message_output::Builder {
        crate::output::redact_channel_message_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutChannelMembershipPreferencesOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The details of a user.</p>
    #[doc(hidden)]
    pub member: std::option::Option<crate::model::Identity>,
    /// <p>The ARN and metadata of the member being added.</p>
    #[doc(hidden)]
    pub preferences: std::option::Option<crate::model::ChannelMembershipPreferences>,
}
impl PutChannelMembershipPreferencesOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The details of a user.</p>
    pub fn member(&self) -> std::option::Option<&crate::model::Identity> {
        self.member.as_ref()
    }
    /// <p>The ARN and metadata of the member being added.</p>
    pub fn preferences(&self) -> std::option::Option<&crate::model::ChannelMembershipPreferences> {
        self.preferences.as_ref()
    }
}
/// See [`PutChannelMembershipPreferencesOutput`](crate::output::PutChannelMembershipPreferencesOutput).
pub mod put_channel_membership_preferences_output {

    /// A builder for [`PutChannelMembershipPreferencesOutput`](crate::output::PutChannelMembershipPreferencesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) member: std::option::Option<crate::model::Identity>,
        pub(crate) preferences: std::option::Option<crate::model::ChannelMembershipPreferences>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The details of a user.</p>
        pub fn member(mut self, input: crate::model::Identity) -> Self {
            self.member = Some(input);
            self
        }
        /// <p>The details of a user.</p>
        pub fn set_member(mut self, input: std::option::Option<crate::model::Identity>) -> Self {
            self.member = input;
            self
        }
        /// <p>The ARN and metadata of the member being added.</p>
        pub fn preferences(mut self, input: crate::model::ChannelMembershipPreferences) -> Self {
            self.preferences = Some(input);
            self
        }
        /// <p>The ARN and metadata of the member being added.</p>
        pub fn set_preferences(
            mut self,
            input: std::option::Option<crate::model::ChannelMembershipPreferences>,
        ) -> Self {
            self.preferences = input;
            self
        }
        /// Consumes the builder and constructs a [`PutChannelMembershipPreferencesOutput`](crate::output::PutChannelMembershipPreferencesOutput).
        pub fn build(self) -> crate::output::PutChannelMembershipPreferencesOutput {
            crate::output::PutChannelMembershipPreferencesOutput {
                channel_arn: self.channel_arn,
                member: self.member,
                preferences: self.preferences,
            }
        }
    }
}
impl PutChannelMembershipPreferencesOutput {
    /// Creates a new builder-style object to manufacture [`PutChannelMembershipPreferencesOutput`](crate::output::PutChannelMembershipPreferencesOutput).
    pub fn builder() -> crate::output::put_channel_membership_preferences_output::Builder {
        crate::output::put_channel_membership_preferences_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTagsForResourceOutput {
    /// <p>The tag key-value pairs.</p>
    #[doc(hidden)]
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl ListTagsForResourceOutput {
    /// <p>The tag key-value pairs.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
}
/// See [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput).
pub mod list_tags_for_resource_output {

    /// A builder for [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    }
    impl Builder {
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tag key-value pairs.</p>
        pub fn tags(mut self, input: crate::model::Tag) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input);
            self.tags = Some(v);
            self
        }
        /// <p>The tag key-value pairs.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> 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 ListSubChannelsOutput {
    /// <p>The ARN of elastic channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The information about each sub-channel.</p>
    #[doc(hidden)]
    pub sub_channels: std::option::Option<std::vec::Vec<crate::model::SubChannelSummary>>,
    /// <p>The token passed by previous API calls until all requested sub-channels are returned.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListSubChannelsOutput {
    /// <p>The ARN of elastic channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The information about each sub-channel.</p>
    pub fn sub_channels(&self) -> std::option::Option<&[crate::model::SubChannelSummary]> {
        self.sub_channels.as_deref()
    }
    /// <p>The token passed by previous API calls until all requested sub-channels are returned.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListSubChannelsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListSubChannelsOutput");
        formatter.field("channel_arn", &self.channel_arn);
        formatter.field("sub_channels", &self.sub_channels);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.finish()
    }
}
/// See [`ListSubChannelsOutput`](crate::output::ListSubChannelsOutput).
pub mod list_sub_channels_output {

    /// A builder for [`ListSubChannelsOutput`](crate::output::ListSubChannelsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) sub_channels:
            std::option::Option<std::vec::Vec<crate::model::SubChannelSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of elastic channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of elastic channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// Appends an item to `sub_channels`.
        ///
        /// To override the contents of this collection use [`set_sub_channels`](Self::set_sub_channels).
        ///
        /// <p>The information about each sub-channel.</p>
        pub fn sub_channels(mut self, input: crate::model::SubChannelSummary) -> Self {
            let mut v = self.sub_channels.unwrap_or_default();
            v.push(input);
            self.sub_channels = Some(v);
            self
        }
        /// <p>The information about each sub-channel.</p>
        pub fn set_sub_channels(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::SubChannelSummary>>,
        ) -> Self {
            self.sub_channels = input;
            self
        }
        /// <p>The token passed by previous API calls until all requested sub-channels are returned.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token passed by previous API calls until all requested sub-channels are returned.</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 [`ListSubChannelsOutput`](crate::output::ListSubChannelsOutput).
        pub fn build(self) -> crate::output::ListSubChannelsOutput {
            crate::output::ListSubChannelsOutput {
                channel_arn: self.channel_arn,
                sub_channels: self.sub_channels,
                next_token: self.next_token,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channel_arn", &self.channel_arn);
            formatter.field("sub_channels", &self.sub_channels);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.finish()
        }
    }
}
impl ListSubChannelsOutput {
    /// Creates a new builder-style object to manufacture [`ListSubChannelsOutput`](crate::output::ListSubChannelsOutput).
    pub fn builder() -> crate::output::list_sub_channels_output::Builder {
        crate::output::list_sub_channels_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelsModeratedByAppInstanceUserOutput {
    /// <p>The moderated channels in the request.</p>
    #[doc(hidden)]
    pub channels:
        std::option::Option<std::vec::Vec<crate::model::ChannelModeratedByAppInstanceUserSummary>>,
    /// <p>The token returned from previous API requests until the number of channels moderated by the user is reached.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListChannelsModeratedByAppInstanceUserOutput {
    /// <p>The moderated channels in the request.</p>
    pub fn channels(
        &self,
    ) -> std::option::Option<&[crate::model::ChannelModeratedByAppInstanceUserSummary]> {
        self.channels.as_deref()
    }
    /// <p>The token returned from previous API requests until the number of channels moderated by the user is reached.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListChannelsModeratedByAppInstanceUserOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelsModeratedByAppInstanceUserOutput");
        formatter.field("channels", &self.channels);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.finish()
    }
}
/// See [`ListChannelsModeratedByAppInstanceUserOutput`](crate::output::ListChannelsModeratedByAppInstanceUserOutput).
pub mod list_channels_moderated_by_app_instance_user_output {

    /// A builder for [`ListChannelsModeratedByAppInstanceUserOutput`](crate::output::ListChannelsModeratedByAppInstanceUserOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channels: std::option::Option<
            std::vec::Vec<crate::model::ChannelModeratedByAppInstanceUserSummary>,
        >,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `channels`.
        ///
        /// To override the contents of this collection use [`set_channels`](Self::set_channels).
        ///
        /// <p>The moderated channels in the request.</p>
        pub fn channels(
            mut self,
            input: crate::model::ChannelModeratedByAppInstanceUserSummary,
        ) -> Self {
            let mut v = self.channels.unwrap_or_default();
            v.push(input);
            self.channels = Some(v);
            self
        }
        /// <p>The moderated channels in the request.</p>
        pub fn set_channels(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::ChannelModeratedByAppInstanceUserSummary>,
            >,
        ) -> Self {
            self.channels = input;
            self
        }
        /// <p>The token returned from previous API requests until the number of channels moderated by the user is reached.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token returned from previous API requests until the number of channels moderated by the user is reached.</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 [`ListChannelsModeratedByAppInstanceUserOutput`](crate::output::ListChannelsModeratedByAppInstanceUserOutput).
        pub fn build(self) -> crate::output::ListChannelsModeratedByAppInstanceUserOutput {
            crate::output::ListChannelsModeratedByAppInstanceUserOutput {
                channels: self.channels,
                next_token: self.next_token,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channels", &self.channels);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.finish()
        }
    }
}
impl ListChannelsModeratedByAppInstanceUserOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelsModeratedByAppInstanceUserOutput`](crate::output::ListChannelsModeratedByAppInstanceUserOutput).
    pub fn builder() -> crate::output::list_channels_moderated_by_app_instance_user_output::Builder
    {
        crate::output::list_channels_moderated_by_app_instance_user_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelsAssociatedWithChannelFlowOutput {
    /// <p>The information about each channel.</p>
    #[doc(hidden)]
    pub channels:
        std::option::Option<std::vec::Vec<crate::model::ChannelAssociatedWithFlowSummary>>,
    /// <p>The token passed by previous API calls until all requested channels are returned.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListChannelsAssociatedWithChannelFlowOutput {
    /// <p>The information about each channel.</p>
    pub fn channels(
        &self,
    ) -> std::option::Option<&[crate::model::ChannelAssociatedWithFlowSummary]> {
        self.channels.as_deref()
    }
    /// <p>The token passed by previous API calls until all requested channels are returned.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListChannelsAssociatedWithChannelFlowOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelsAssociatedWithChannelFlowOutput");
        formatter.field("channels", &self.channels);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.finish()
    }
}
/// See [`ListChannelsAssociatedWithChannelFlowOutput`](crate::output::ListChannelsAssociatedWithChannelFlowOutput).
pub mod list_channels_associated_with_channel_flow_output {

    /// A builder for [`ListChannelsAssociatedWithChannelFlowOutput`](crate::output::ListChannelsAssociatedWithChannelFlowOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channels:
            std::option::Option<std::vec::Vec<crate::model::ChannelAssociatedWithFlowSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `channels`.
        ///
        /// To override the contents of this collection use [`set_channels`](Self::set_channels).
        ///
        /// <p>The information about each channel.</p>
        pub fn channels(mut self, input: crate::model::ChannelAssociatedWithFlowSummary) -> Self {
            let mut v = self.channels.unwrap_or_default();
            v.push(input);
            self.channels = Some(v);
            self
        }
        /// <p>The information about each channel.</p>
        pub fn set_channels(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::ChannelAssociatedWithFlowSummary>,
            >,
        ) -> Self {
            self.channels = input;
            self
        }
        /// <p>The token passed by previous API calls until all requested channels are returned.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token passed by previous API calls until all requested channels are returned.</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 [`ListChannelsAssociatedWithChannelFlowOutput`](crate::output::ListChannelsAssociatedWithChannelFlowOutput).
        pub fn build(self) -> crate::output::ListChannelsAssociatedWithChannelFlowOutput {
            crate::output::ListChannelsAssociatedWithChannelFlowOutput {
                channels: self.channels,
                next_token: self.next_token,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channels", &self.channels);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.finish()
        }
    }
}
impl ListChannelsAssociatedWithChannelFlowOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelsAssociatedWithChannelFlowOutput`](crate::output::ListChannelsAssociatedWithChannelFlowOutput).
    pub fn builder() -> crate::output::list_channels_associated_with_channel_flow_output::Builder {
        crate::output::list_channels_associated_with_channel_flow_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelsOutput {
    /// <p>The information about each channel.</p>
    #[doc(hidden)]
    pub channels: std::option::Option<std::vec::Vec<crate::model::ChannelSummary>>,
    /// <p>The token returned from previous API requests until the number of channels is reached.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListChannelsOutput {
    /// <p>The information about each channel.</p>
    pub fn channels(&self) -> std::option::Option<&[crate::model::ChannelSummary]> {
        self.channels.as_deref()
    }
    /// <p>The token returned from previous API requests until the number of channels is reached.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListChannelsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelsOutput");
        formatter.field("channels", &self.channels);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.finish()
    }
}
/// See [`ListChannelsOutput`](crate::output::ListChannelsOutput).
pub mod list_channels_output {

    /// A builder for [`ListChannelsOutput`](crate::output::ListChannelsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channels: std::option::Option<std::vec::Vec<crate::model::ChannelSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `channels`.
        ///
        /// To override the contents of this collection use [`set_channels`](Self::set_channels).
        ///
        /// <p>The information about each channel.</p>
        pub fn channels(mut self, input: crate::model::ChannelSummary) -> Self {
            let mut v = self.channels.unwrap_or_default();
            v.push(input);
            self.channels = Some(v);
            self
        }
        /// <p>The information about each channel.</p>
        pub fn set_channels(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ChannelSummary>>,
        ) -> Self {
            self.channels = input;
            self
        }
        /// <p>The token returned from previous API requests until the number of channels is reached.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token returned from previous API requests until the number of channels is reached.</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 [`ListChannelsOutput`](crate::output::ListChannelsOutput).
        pub fn build(self) -> crate::output::ListChannelsOutput {
            crate::output::ListChannelsOutput {
                channels: self.channels,
                next_token: self.next_token,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channels", &self.channels);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.finish()
        }
    }
}
impl ListChannelsOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelsOutput`](crate::output::ListChannelsOutput).
    pub fn builder() -> crate::output::list_channels_output::Builder {
        crate::output::list_channels_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelModeratorsOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The token passed by previous API calls until all requested moderators are returned.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The information about and names of each moderator.</p>
    #[doc(hidden)]
    pub channel_moderators:
        std::option::Option<std::vec::Vec<crate::model::ChannelModeratorSummary>>,
}
impl ListChannelModeratorsOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The token passed by previous API calls until all requested moderators are returned.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The information about and names of each moderator.</p>
    pub fn channel_moderators(
        &self,
    ) -> std::option::Option<&[crate::model::ChannelModeratorSummary]> {
        self.channel_moderators.as_deref()
    }
}
impl std::fmt::Debug for ListChannelModeratorsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelModeratorsOutput");
        formatter.field("channel_arn", &self.channel_arn);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.field("channel_moderators", &self.channel_moderators);
        formatter.finish()
    }
}
/// See [`ListChannelModeratorsOutput`](crate::output::ListChannelModeratorsOutput).
pub mod list_channel_moderators_output {

    /// A builder for [`ListChannelModeratorsOutput`](crate::output::ListChannelModeratorsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) channel_moderators:
            std::option::Option<std::vec::Vec<crate::model::ChannelModeratorSummary>>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The token passed by previous API calls until all requested moderators are returned.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token passed by previous API calls until all requested moderators are returned.</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 `channel_moderators`.
        ///
        /// To override the contents of this collection use [`set_channel_moderators`](Self::set_channel_moderators).
        ///
        /// <p>The information about and names of each moderator.</p>
        pub fn channel_moderators(mut self, input: crate::model::ChannelModeratorSummary) -> Self {
            let mut v = self.channel_moderators.unwrap_or_default();
            v.push(input);
            self.channel_moderators = Some(v);
            self
        }
        /// <p>The information about and names of each moderator.</p>
        pub fn set_channel_moderators(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ChannelModeratorSummary>>,
        ) -> Self {
            self.channel_moderators = input;
            self
        }
        /// Consumes the builder and constructs a [`ListChannelModeratorsOutput`](crate::output::ListChannelModeratorsOutput).
        pub fn build(self) -> crate::output::ListChannelModeratorsOutput {
            crate::output::ListChannelModeratorsOutput {
                channel_arn: self.channel_arn,
                next_token: self.next_token,
                channel_moderators: self.channel_moderators,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channel_arn", &self.channel_arn);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.field("channel_moderators", &self.channel_moderators);
            formatter.finish()
        }
    }
}
impl ListChannelModeratorsOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelModeratorsOutput`](crate::output::ListChannelModeratorsOutput).
    pub fn builder() -> crate::output::list_channel_moderators_output::Builder {
        crate::output::list_channel_moderators_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelMessagesOutput {
    /// <p>The ARN of the channel containing the requested messages.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The token passed by previous API calls until all requested messages are returned.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The information about, and content of, each requested message.</p>
    #[doc(hidden)]
    pub channel_messages: std::option::Option<std::vec::Vec<crate::model::ChannelMessageSummary>>,
    /// <p>The ID of the SubChannel in the response.</p>
    #[doc(hidden)]
    pub sub_channel_id: std::option::Option<std::string::String>,
}
impl ListChannelMessagesOutput {
    /// <p>The ARN of the channel containing the requested messages.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The token passed by previous API calls until all requested messages are returned.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The information about, and content of, each requested message.</p>
    pub fn channel_messages(&self) -> std::option::Option<&[crate::model::ChannelMessageSummary]> {
        self.channel_messages.as_deref()
    }
    /// <p>The ID of the SubChannel in the response.</p>
    pub fn sub_channel_id(&self) -> std::option::Option<&str> {
        self.sub_channel_id.as_deref()
    }
}
impl std::fmt::Debug for ListChannelMessagesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelMessagesOutput");
        formatter.field("channel_arn", &self.channel_arn);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.field("channel_messages", &self.channel_messages);
        formatter.field("sub_channel_id", &self.sub_channel_id);
        formatter.finish()
    }
}
/// See [`ListChannelMessagesOutput`](crate::output::ListChannelMessagesOutput).
pub mod list_channel_messages_output {

    /// A builder for [`ListChannelMessagesOutput`](crate::output::ListChannelMessagesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) channel_messages:
            std::option::Option<std::vec::Vec<crate::model::ChannelMessageSummary>>,
        pub(crate) sub_channel_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel containing the requested messages.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel containing the requested messages.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The token passed by previous API calls until all requested messages are returned.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token passed by previous API calls until all requested messages are returned.</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 `channel_messages`.
        ///
        /// To override the contents of this collection use [`set_channel_messages`](Self::set_channel_messages).
        ///
        /// <p>The information about, and content of, each requested message.</p>
        pub fn channel_messages(mut self, input: crate::model::ChannelMessageSummary) -> Self {
            let mut v = self.channel_messages.unwrap_or_default();
            v.push(input);
            self.channel_messages = Some(v);
            self
        }
        /// <p>The information about, and content of, each requested message.</p>
        pub fn set_channel_messages(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ChannelMessageSummary>>,
        ) -> Self {
            self.channel_messages = input;
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn sub_channel_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.sub_channel_id = Some(input.into());
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn set_sub_channel_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.sub_channel_id = input;
            self
        }
        /// Consumes the builder and constructs a [`ListChannelMessagesOutput`](crate::output::ListChannelMessagesOutput).
        pub fn build(self) -> crate::output::ListChannelMessagesOutput {
            crate::output::ListChannelMessagesOutput {
                channel_arn: self.channel_arn,
                next_token: self.next_token,
                channel_messages: self.channel_messages,
                sub_channel_id: self.sub_channel_id,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channel_arn", &self.channel_arn);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.field("channel_messages", &self.channel_messages);
            formatter.field("sub_channel_id", &self.sub_channel_id);
            formatter.finish()
        }
    }
}
impl ListChannelMessagesOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelMessagesOutput`](crate::output::ListChannelMessagesOutput).
    pub fn builder() -> crate::output::list_channel_messages_output::Builder {
        crate::output::list_channel_messages_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelMembershipsForAppInstanceUserOutput {
    /// <p>The information for the requested channel memberships.</p>
    #[doc(hidden)]
    pub channel_memberships: std::option::Option<
        std::vec::Vec<crate::model::ChannelMembershipForAppInstanceUserSummary>,
    >,
    /// <p>The token passed by previous API calls until all requested users are returned.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListChannelMembershipsForAppInstanceUserOutput {
    /// <p>The information for the requested channel memberships.</p>
    pub fn channel_memberships(
        &self,
    ) -> std::option::Option<&[crate::model::ChannelMembershipForAppInstanceUserSummary]> {
        self.channel_memberships.as_deref()
    }
    /// <p>The token passed by previous API calls until all requested users are returned.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListChannelMembershipsForAppInstanceUserOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelMembershipsForAppInstanceUserOutput");
        formatter.field("channel_memberships", &self.channel_memberships);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.finish()
    }
}
/// See [`ListChannelMembershipsForAppInstanceUserOutput`](crate::output::ListChannelMembershipsForAppInstanceUserOutput).
pub mod list_channel_memberships_for_app_instance_user_output {

    /// A builder for [`ListChannelMembershipsForAppInstanceUserOutput`](crate::output::ListChannelMembershipsForAppInstanceUserOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channel_memberships: std::option::Option<
            std::vec::Vec<crate::model::ChannelMembershipForAppInstanceUserSummary>,
        >,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `channel_memberships`.
        ///
        /// To override the contents of this collection use [`set_channel_memberships`](Self::set_channel_memberships).
        ///
        /// <p>The information for the requested channel memberships.</p>
        pub fn channel_memberships(
            mut self,
            input: crate::model::ChannelMembershipForAppInstanceUserSummary,
        ) -> Self {
            let mut v = self.channel_memberships.unwrap_or_default();
            v.push(input);
            self.channel_memberships = Some(v);
            self
        }
        /// <p>The information for the requested channel memberships.</p>
        pub fn set_channel_memberships(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::ChannelMembershipForAppInstanceUserSummary>,
            >,
        ) -> Self {
            self.channel_memberships = input;
            self
        }
        /// <p>The token passed by previous API calls until all requested users are returned.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token passed by previous API calls until all requested users are returned.</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 [`ListChannelMembershipsForAppInstanceUserOutput`](crate::output::ListChannelMembershipsForAppInstanceUserOutput).
        pub fn build(self) -> crate::output::ListChannelMembershipsForAppInstanceUserOutput {
            crate::output::ListChannelMembershipsForAppInstanceUserOutput {
                channel_memberships: self.channel_memberships,
                next_token: self.next_token,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channel_memberships", &self.channel_memberships);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.finish()
        }
    }
}
impl ListChannelMembershipsForAppInstanceUserOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelMembershipsForAppInstanceUserOutput`](crate::output::ListChannelMembershipsForAppInstanceUserOutput).
    pub fn builder() -> crate::output::list_channel_memberships_for_app_instance_user_output::Builder
    {
        crate::output::list_channel_memberships_for_app_instance_user_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelMembershipsOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The information for the requested channel memberships.</p>
    #[doc(hidden)]
    pub channel_memberships:
        std::option::Option<std::vec::Vec<crate::model::ChannelMembershipSummary>>,
    /// <p>The token passed by previous API calls until all requested channel memberships are returned.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListChannelMembershipsOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The information for the requested channel memberships.</p>
    pub fn channel_memberships(
        &self,
    ) -> std::option::Option<&[crate::model::ChannelMembershipSummary]> {
        self.channel_memberships.as_deref()
    }
    /// <p>The token passed by previous API calls until all requested channel memberships are returned.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListChannelMembershipsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelMembershipsOutput");
        formatter.field("channel_arn", &self.channel_arn);
        formatter.field("channel_memberships", &self.channel_memberships);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.finish()
    }
}
/// See [`ListChannelMembershipsOutput`](crate::output::ListChannelMembershipsOutput).
pub mod list_channel_memberships_output {

    /// A builder for [`ListChannelMembershipsOutput`](crate::output::ListChannelMembershipsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) channel_memberships:
            std::option::Option<std::vec::Vec<crate::model::ChannelMembershipSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// Appends an item to `channel_memberships`.
        ///
        /// To override the contents of this collection use [`set_channel_memberships`](Self::set_channel_memberships).
        ///
        /// <p>The information for the requested channel memberships.</p>
        pub fn channel_memberships(
            mut self,
            input: crate::model::ChannelMembershipSummary,
        ) -> Self {
            let mut v = self.channel_memberships.unwrap_or_default();
            v.push(input);
            self.channel_memberships = Some(v);
            self
        }
        /// <p>The information for the requested channel memberships.</p>
        pub fn set_channel_memberships(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ChannelMembershipSummary>>,
        ) -> Self {
            self.channel_memberships = input;
            self
        }
        /// <p>The token passed by previous API calls until all requested channel memberships are returned.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token passed by previous API calls until all requested channel memberships are returned.</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 [`ListChannelMembershipsOutput`](crate::output::ListChannelMembershipsOutput).
        pub fn build(self) -> crate::output::ListChannelMembershipsOutput {
            crate::output::ListChannelMembershipsOutput {
                channel_arn: self.channel_arn,
                channel_memberships: self.channel_memberships,
                next_token: self.next_token,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channel_arn", &self.channel_arn);
            formatter.field("channel_memberships", &self.channel_memberships);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.finish()
        }
    }
}
impl ListChannelMembershipsOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelMembershipsOutput`](crate::output::ListChannelMembershipsOutput).
    pub fn builder() -> crate::output::list_channel_memberships_output::Builder {
        crate::output::list_channel_memberships_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelFlowsOutput {
    /// <p>The information about each channel flow.</p>
    #[doc(hidden)]
    pub channel_flows: std::option::Option<std::vec::Vec<crate::model::ChannelFlowSummary>>,
    /// <p>The token passed by previous API calls until all requested channels are returned.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListChannelFlowsOutput {
    /// <p>The information about each channel flow.</p>
    pub fn channel_flows(&self) -> std::option::Option<&[crate::model::ChannelFlowSummary]> {
        self.channel_flows.as_deref()
    }
    /// <p>The token passed by previous API calls until all requested channels are returned.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListChannelFlowsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelFlowsOutput");
        formatter.field("channel_flows", &self.channel_flows);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.finish()
    }
}
/// See [`ListChannelFlowsOutput`](crate::output::ListChannelFlowsOutput).
pub mod list_channel_flows_output {

    /// A builder for [`ListChannelFlowsOutput`](crate::output::ListChannelFlowsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channel_flows:
            std::option::Option<std::vec::Vec<crate::model::ChannelFlowSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `channel_flows`.
        ///
        /// To override the contents of this collection use [`set_channel_flows`](Self::set_channel_flows).
        ///
        /// <p>The information about each channel flow.</p>
        pub fn channel_flows(mut self, input: crate::model::ChannelFlowSummary) -> Self {
            let mut v = self.channel_flows.unwrap_or_default();
            v.push(input);
            self.channel_flows = Some(v);
            self
        }
        /// <p>The information about each channel flow.</p>
        pub fn set_channel_flows(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ChannelFlowSummary>>,
        ) -> Self {
            self.channel_flows = input;
            self
        }
        /// <p>The token passed by previous API calls until all requested channels are returned.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token passed by previous API calls until all requested channels are returned.</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 [`ListChannelFlowsOutput`](crate::output::ListChannelFlowsOutput).
        pub fn build(self) -> crate::output::ListChannelFlowsOutput {
            crate::output::ListChannelFlowsOutput {
                channel_flows: self.channel_flows,
                next_token: self.next_token,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channel_flows", &self.channel_flows);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.finish()
        }
    }
}
impl ListChannelFlowsOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelFlowsOutput`](crate::output::ListChannelFlowsOutput).
    pub fn builder() -> crate::output::list_channel_flows_output::Builder {
        crate::output::list_channel_flows_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListChannelBansOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The token passed by previous API calls until all requested bans are returned.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The information for each requested ban.</p>
    #[doc(hidden)]
    pub channel_bans: std::option::Option<std::vec::Vec<crate::model::ChannelBanSummary>>,
}
impl ListChannelBansOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The token passed by previous API calls until all requested bans are returned.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The information for each requested ban.</p>
    pub fn channel_bans(&self) -> std::option::Option<&[crate::model::ChannelBanSummary]> {
        self.channel_bans.as_deref()
    }
}
impl std::fmt::Debug for ListChannelBansOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListChannelBansOutput");
        formatter.field("channel_arn", &self.channel_arn);
        formatter.field("next_token", &"*** Sensitive Data Redacted ***");
        formatter.field("channel_bans", &self.channel_bans);
        formatter.finish()
    }
}
/// See [`ListChannelBansOutput`](crate::output::ListChannelBansOutput).
pub mod list_channel_bans_output {

    /// A builder for [`ListChannelBansOutput`](crate::output::ListChannelBansOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) channel_bans:
            std::option::Option<std::vec::Vec<crate::model::ChannelBanSummary>>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The token passed by previous API calls until all requested bans are returned.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token passed by previous API calls until all requested bans are returned.</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 `channel_bans`.
        ///
        /// To override the contents of this collection use [`set_channel_bans`](Self::set_channel_bans).
        ///
        /// <p>The information for each requested ban.</p>
        pub fn channel_bans(mut self, input: crate::model::ChannelBanSummary) -> Self {
            let mut v = self.channel_bans.unwrap_or_default();
            v.push(input);
            self.channel_bans = Some(v);
            self
        }
        /// <p>The information for each requested ban.</p>
        pub fn set_channel_bans(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ChannelBanSummary>>,
        ) -> Self {
            self.channel_bans = input;
            self
        }
        /// Consumes the builder and constructs a [`ListChannelBansOutput`](crate::output::ListChannelBansOutput).
        pub fn build(self) -> crate::output::ListChannelBansOutput {
            crate::output::ListChannelBansOutput {
                channel_arn: self.channel_arn,
                next_token: self.next_token,
                channel_bans: self.channel_bans,
            }
        }
    }
    impl std::fmt::Debug for Builder {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut formatter = f.debug_struct("Builder");
            formatter.field("channel_arn", &self.channel_arn);
            formatter.field("next_token", &"*** Sensitive Data Redacted ***");
            formatter.field("channel_bans", &self.channel_bans);
            formatter.finish()
        }
    }
}
impl ListChannelBansOutput {
    /// Creates a new builder-style object to manufacture [`ListChannelBansOutput`](crate::output::ListChannelBansOutput).
    pub fn builder() -> crate::output::list_channel_bans_output::Builder {
        crate::output::list_channel_bans_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetMessagingSessionEndpointOutput {
    /// <p>The endpoint returned in the response.</p>
    #[doc(hidden)]
    pub endpoint: std::option::Option<crate::model::MessagingSessionEndpoint>,
}
impl GetMessagingSessionEndpointOutput {
    /// <p>The endpoint returned in the response.</p>
    pub fn endpoint(&self) -> std::option::Option<&crate::model::MessagingSessionEndpoint> {
        self.endpoint.as_ref()
    }
}
/// See [`GetMessagingSessionEndpointOutput`](crate::output::GetMessagingSessionEndpointOutput).
pub mod get_messaging_session_endpoint_output {

    /// A builder for [`GetMessagingSessionEndpointOutput`](crate::output::GetMessagingSessionEndpointOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) endpoint: std::option::Option<crate::model::MessagingSessionEndpoint>,
    }
    impl Builder {
        /// <p>The endpoint returned in the response.</p>
        pub fn endpoint(mut self, input: crate::model::MessagingSessionEndpoint) -> Self {
            self.endpoint = Some(input);
            self
        }
        /// <p>The endpoint returned in the response.</p>
        pub fn set_endpoint(
            mut self,
            input: std::option::Option<crate::model::MessagingSessionEndpoint>,
        ) -> Self {
            self.endpoint = input;
            self
        }
        /// Consumes the builder and constructs a [`GetMessagingSessionEndpointOutput`](crate::output::GetMessagingSessionEndpointOutput).
        pub fn build(self) -> crate::output::GetMessagingSessionEndpointOutput {
            crate::output::GetMessagingSessionEndpointOutput {
                endpoint: self.endpoint,
            }
        }
    }
}
impl GetMessagingSessionEndpointOutput {
    /// Creates a new builder-style object to manufacture [`GetMessagingSessionEndpointOutput`](crate::output::GetMessagingSessionEndpointOutput).
    pub fn builder() -> crate::output::get_messaging_session_endpoint_output::Builder {
        crate::output::get_messaging_session_endpoint_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetChannelMessageStatusOutput {
    /// <p>The message status and details.</p>
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::ChannelMessageStatusStructure>,
}
impl GetChannelMessageStatusOutput {
    /// <p>The message status and details.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::ChannelMessageStatusStructure> {
        self.status.as_ref()
    }
}
/// See [`GetChannelMessageStatusOutput`](crate::output::GetChannelMessageStatusOutput).
pub mod get_channel_message_status_output {

    /// A builder for [`GetChannelMessageStatusOutput`](crate::output::GetChannelMessageStatusOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::ChannelMessageStatusStructure>,
    }
    impl Builder {
        /// <p>The message status and details.</p>
        pub fn status(mut self, input: crate::model::ChannelMessageStatusStructure) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>The message status and details.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::ChannelMessageStatusStructure>,
        ) -> Self {
            self.status = input;
            self
        }
        /// Consumes the builder and constructs a [`GetChannelMessageStatusOutput`](crate::output::GetChannelMessageStatusOutput).
        pub fn build(self) -> crate::output::GetChannelMessageStatusOutput {
            crate::output::GetChannelMessageStatusOutput {
                status: self.status,
            }
        }
    }
}
impl GetChannelMessageStatusOutput {
    /// Creates a new builder-style object to manufacture [`GetChannelMessageStatusOutput`](crate::output::GetChannelMessageStatusOutput).
    pub fn builder() -> crate::output::get_channel_message_status_output::Builder {
        crate::output::get_channel_message_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetChannelMessageOutput {
    /// <p>The details of and content in the message.</p>
    #[doc(hidden)]
    pub channel_message: std::option::Option<crate::model::ChannelMessage>,
}
impl GetChannelMessageOutput {
    /// <p>The details of and content in the message.</p>
    pub fn channel_message(&self) -> std::option::Option<&crate::model::ChannelMessage> {
        self.channel_message.as_ref()
    }
}
/// See [`GetChannelMessageOutput`](crate::output::GetChannelMessageOutput).
pub mod get_channel_message_output {

    /// A builder for [`GetChannelMessageOutput`](crate::output::GetChannelMessageOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_message: std::option::Option<crate::model::ChannelMessage>,
    }
    impl Builder {
        /// <p>The details of and content in the message.</p>
        pub fn channel_message(mut self, input: crate::model::ChannelMessage) -> Self {
            self.channel_message = Some(input);
            self
        }
        /// <p>The details of and content in the message.</p>
        pub fn set_channel_message(
            mut self,
            input: std::option::Option<crate::model::ChannelMessage>,
        ) -> Self {
            self.channel_message = input;
            self
        }
        /// Consumes the builder and constructs a [`GetChannelMessageOutput`](crate::output::GetChannelMessageOutput).
        pub fn build(self) -> crate::output::GetChannelMessageOutput {
            crate::output::GetChannelMessageOutput {
                channel_message: self.channel_message,
            }
        }
    }
}
impl GetChannelMessageOutput {
    /// Creates a new builder-style object to manufacture [`GetChannelMessageOutput`](crate::output::GetChannelMessageOutput).
    pub fn builder() -> crate::output::get_channel_message_output::Builder {
        crate::output::get_channel_message_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetChannelMembershipPreferencesOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The details of a user.</p>
    #[doc(hidden)]
    pub member: std::option::Option<crate::model::Identity>,
    /// <p>The channel membership preferences for an <code>AppInstanceUser</code> .</p>
    #[doc(hidden)]
    pub preferences: std::option::Option<crate::model::ChannelMembershipPreferences>,
}
impl GetChannelMembershipPreferencesOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The details of a user.</p>
    pub fn member(&self) -> std::option::Option<&crate::model::Identity> {
        self.member.as_ref()
    }
    /// <p>The channel membership preferences for an <code>AppInstanceUser</code> .</p>
    pub fn preferences(&self) -> std::option::Option<&crate::model::ChannelMembershipPreferences> {
        self.preferences.as_ref()
    }
}
/// See [`GetChannelMembershipPreferencesOutput`](crate::output::GetChannelMembershipPreferencesOutput).
pub mod get_channel_membership_preferences_output {

    /// A builder for [`GetChannelMembershipPreferencesOutput`](crate::output::GetChannelMembershipPreferencesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) member: std::option::Option<crate::model::Identity>,
        pub(crate) preferences: std::option::Option<crate::model::ChannelMembershipPreferences>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The details of a user.</p>
        pub fn member(mut self, input: crate::model::Identity) -> Self {
            self.member = Some(input);
            self
        }
        /// <p>The details of a user.</p>
        pub fn set_member(mut self, input: std::option::Option<crate::model::Identity>) -> Self {
            self.member = input;
            self
        }
        /// <p>The channel membership preferences for an <code>AppInstanceUser</code> .</p>
        pub fn preferences(mut self, input: crate::model::ChannelMembershipPreferences) -> Self {
            self.preferences = Some(input);
            self
        }
        /// <p>The channel membership preferences for an <code>AppInstanceUser</code> .</p>
        pub fn set_preferences(
            mut self,
            input: std::option::Option<crate::model::ChannelMembershipPreferences>,
        ) -> Self {
            self.preferences = input;
            self
        }
        /// Consumes the builder and constructs a [`GetChannelMembershipPreferencesOutput`](crate::output::GetChannelMembershipPreferencesOutput).
        pub fn build(self) -> crate::output::GetChannelMembershipPreferencesOutput {
            crate::output::GetChannelMembershipPreferencesOutput {
                channel_arn: self.channel_arn,
                member: self.member,
                preferences: self.preferences,
            }
        }
    }
}
impl GetChannelMembershipPreferencesOutput {
    /// Creates a new builder-style object to manufacture [`GetChannelMembershipPreferencesOutput`](crate::output::GetChannelMembershipPreferencesOutput).
    pub fn builder() -> crate::output::get_channel_membership_preferences_output::Builder {
        crate::output::get_channel_membership_preferences_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DisassociateChannelFlowOutput {}
/// See [`DisassociateChannelFlowOutput`](crate::output::DisassociateChannelFlowOutput).
pub mod disassociate_channel_flow_output {

    /// A builder for [`DisassociateChannelFlowOutput`](crate::output::DisassociateChannelFlowOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DisassociateChannelFlowOutput`](crate::output::DisassociateChannelFlowOutput).
        pub fn build(self) -> crate::output::DisassociateChannelFlowOutput {
            crate::output::DisassociateChannelFlowOutput {}
        }
    }
}
impl DisassociateChannelFlowOutput {
    /// Creates a new builder-style object to manufacture [`DisassociateChannelFlowOutput`](crate::output::DisassociateChannelFlowOutput).
    pub fn builder() -> crate::output::disassociate_channel_flow_output::Builder {
        crate::output::disassociate_channel_flow_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeChannelModeratorOutput {
    /// <p>The details of the channel moderator.</p>
    #[doc(hidden)]
    pub channel_moderator: std::option::Option<crate::model::ChannelModerator>,
}
impl DescribeChannelModeratorOutput {
    /// <p>The details of the channel moderator.</p>
    pub fn channel_moderator(&self) -> std::option::Option<&crate::model::ChannelModerator> {
        self.channel_moderator.as_ref()
    }
}
/// See [`DescribeChannelModeratorOutput`](crate::output::DescribeChannelModeratorOutput).
pub mod describe_channel_moderator_output {

    /// A builder for [`DescribeChannelModeratorOutput`](crate::output::DescribeChannelModeratorOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_moderator: std::option::Option<crate::model::ChannelModerator>,
    }
    impl Builder {
        /// <p>The details of the channel moderator.</p>
        pub fn channel_moderator(mut self, input: crate::model::ChannelModerator) -> Self {
            self.channel_moderator = Some(input);
            self
        }
        /// <p>The details of the channel moderator.</p>
        pub fn set_channel_moderator(
            mut self,
            input: std::option::Option<crate::model::ChannelModerator>,
        ) -> Self {
            self.channel_moderator = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeChannelModeratorOutput`](crate::output::DescribeChannelModeratorOutput).
        pub fn build(self) -> crate::output::DescribeChannelModeratorOutput {
            crate::output::DescribeChannelModeratorOutput {
                channel_moderator: self.channel_moderator,
            }
        }
    }
}
impl DescribeChannelModeratorOutput {
    /// Creates a new builder-style object to manufacture [`DescribeChannelModeratorOutput`](crate::output::DescribeChannelModeratorOutput).
    pub fn builder() -> crate::output::describe_channel_moderator_output::Builder {
        crate::output::describe_channel_moderator_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeChannelModeratedByAppInstanceUserOutput {
    /// <p>The moderated channel.</p>
    #[doc(hidden)]
    pub channel: std::option::Option<crate::model::ChannelModeratedByAppInstanceUserSummary>,
}
impl DescribeChannelModeratedByAppInstanceUserOutput {
    /// <p>The moderated channel.</p>
    pub fn channel(
        &self,
    ) -> std::option::Option<&crate::model::ChannelModeratedByAppInstanceUserSummary> {
        self.channel.as_ref()
    }
}
/// See [`DescribeChannelModeratedByAppInstanceUserOutput`](crate::output::DescribeChannelModeratedByAppInstanceUserOutput).
pub mod describe_channel_moderated_by_app_instance_user_output {

    /// A builder for [`DescribeChannelModeratedByAppInstanceUserOutput`](crate::output::DescribeChannelModeratedByAppInstanceUserOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel:
            std::option::Option<crate::model::ChannelModeratedByAppInstanceUserSummary>,
    }
    impl Builder {
        /// <p>The moderated channel.</p>
        pub fn channel(
            mut self,
            input: crate::model::ChannelModeratedByAppInstanceUserSummary,
        ) -> Self {
            self.channel = Some(input);
            self
        }
        /// <p>The moderated channel.</p>
        pub fn set_channel(
            mut self,
            input: std::option::Option<crate::model::ChannelModeratedByAppInstanceUserSummary>,
        ) -> Self {
            self.channel = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeChannelModeratedByAppInstanceUserOutput`](crate::output::DescribeChannelModeratedByAppInstanceUserOutput).
        pub fn build(self) -> crate::output::DescribeChannelModeratedByAppInstanceUserOutput {
            crate::output::DescribeChannelModeratedByAppInstanceUserOutput {
                channel: self.channel,
            }
        }
    }
}
impl DescribeChannelModeratedByAppInstanceUserOutput {
    /// Creates a new builder-style object to manufacture [`DescribeChannelModeratedByAppInstanceUserOutput`](crate::output::DescribeChannelModeratedByAppInstanceUserOutput).
    pub fn builder(
    ) -> crate::output::describe_channel_moderated_by_app_instance_user_output::Builder {
        crate::output::describe_channel_moderated_by_app_instance_user_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeChannelMembershipForAppInstanceUserOutput {
    /// <p>The channel to which a user belongs.</p>
    #[doc(hidden)]
    pub channel_membership:
        std::option::Option<crate::model::ChannelMembershipForAppInstanceUserSummary>,
}
impl DescribeChannelMembershipForAppInstanceUserOutput {
    /// <p>The channel to which a user belongs.</p>
    pub fn channel_membership(
        &self,
    ) -> std::option::Option<&crate::model::ChannelMembershipForAppInstanceUserSummary> {
        self.channel_membership.as_ref()
    }
}
/// See [`DescribeChannelMembershipForAppInstanceUserOutput`](crate::output::DescribeChannelMembershipForAppInstanceUserOutput).
pub mod describe_channel_membership_for_app_instance_user_output {

    /// A builder for [`DescribeChannelMembershipForAppInstanceUserOutput`](crate::output::DescribeChannelMembershipForAppInstanceUserOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_membership:
            std::option::Option<crate::model::ChannelMembershipForAppInstanceUserSummary>,
    }
    impl Builder {
        /// <p>The channel to which a user belongs.</p>
        pub fn channel_membership(
            mut self,
            input: crate::model::ChannelMembershipForAppInstanceUserSummary,
        ) -> Self {
            self.channel_membership = Some(input);
            self
        }
        /// <p>The channel to which a user belongs.</p>
        pub fn set_channel_membership(
            mut self,
            input: std::option::Option<crate::model::ChannelMembershipForAppInstanceUserSummary>,
        ) -> Self {
            self.channel_membership = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeChannelMembershipForAppInstanceUserOutput`](crate::output::DescribeChannelMembershipForAppInstanceUserOutput).
        pub fn build(self) -> crate::output::DescribeChannelMembershipForAppInstanceUserOutput {
            crate::output::DescribeChannelMembershipForAppInstanceUserOutput {
                channel_membership: self.channel_membership,
            }
        }
    }
}
impl DescribeChannelMembershipForAppInstanceUserOutput {
    /// Creates a new builder-style object to manufacture [`DescribeChannelMembershipForAppInstanceUserOutput`](crate::output::DescribeChannelMembershipForAppInstanceUserOutput).
    pub fn builder(
    ) -> crate::output::describe_channel_membership_for_app_instance_user_output::Builder {
        crate::output::describe_channel_membership_for_app_instance_user_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeChannelMembershipOutput {
    /// <p>The details of the membership.</p>
    #[doc(hidden)]
    pub channel_membership: std::option::Option<crate::model::ChannelMembership>,
}
impl DescribeChannelMembershipOutput {
    /// <p>The details of the membership.</p>
    pub fn channel_membership(&self) -> std::option::Option<&crate::model::ChannelMembership> {
        self.channel_membership.as_ref()
    }
}
/// See [`DescribeChannelMembershipOutput`](crate::output::DescribeChannelMembershipOutput).
pub mod describe_channel_membership_output {

    /// A builder for [`DescribeChannelMembershipOutput`](crate::output::DescribeChannelMembershipOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_membership: std::option::Option<crate::model::ChannelMembership>,
    }
    impl Builder {
        /// <p>The details of the membership.</p>
        pub fn channel_membership(mut self, input: crate::model::ChannelMembership) -> Self {
            self.channel_membership = Some(input);
            self
        }
        /// <p>The details of the membership.</p>
        pub fn set_channel_membership(
            mut self,
            input: std::option::Option<crate::model::ChannelMembership>,
        ) -> Self {
            self.channel_membership = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeChannelMembershipOutput`](crate::output::DescribeChannelMembershipOutput).
        pub fn build(self) -> crate::output::DescribeChannelMembershipOutput {
            crate::output::DescribeChannelMembershipOutput {
                channel_membership: self.channel_membership,
            }
        }
    }
}
impl DescribeChannelMembershipOutput {
    /// Creates a new builder-style object to manufacture [`DescribeChannelMembershipOutput`](crate::output::DescribeChannelMembershipOutput).
    pub fn builder() -> crate::output::describe_channel_membership_output::Builder {
        crate::output::describe_channel_membership_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeChannelFlowOutput {
    /// <p>The channel flow details.</p>
    #[doc(hidden)]
    pub channel_flow: std::option::Option<crate::model::ChannelFlow>,
}
impl DescribeChannelFlowOutput {
    /// <p>The channel flow details.</p>
    pub fn channel_flow(&self) -> std::option::Option<&crate::model::ChannelFlow> {
        self.channel_flow.as_ref()
    }
}
/// See [`DescribeChannelFlowOutput`](crate::output::DescribeChannelFlowOutput).
pub mod describe_channel_flow_output {

    /// A builder for [`DescribeChannelFlowOutput`](crate::output::DescribeChannelFlowOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_flow: std::option::Option<crate::model::ChannelFlow>,
    }
    impl Builder {
        /// <p>The channel flow details.</p>
        pub fn channel_flow(mut self, input: crate::model::ChannelFlow) -> Self {
            self.channel_flow = Some(input);
            self
        }
        /// <p>The channel flow details.</p>
        pub fn set_channel_flow(
            mut self,
            input: std::option::Option<crate::model::ChannelFlow>,
        ) -> Self {
            self.channel_flow = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeChannelFlowOutput`](crate::output::DescribeChannelFlowOutput).
        pub fn build(self) -> crate::output::DescribeChannelFlowOutput {
            crate::output::DescribeChannelFlowOutput {
                channel_flow: self.channel_flow,
            }
        }
    }
}
impl DescribeChannelFlowOutput {
    /// Creates a new builder-style object to manufacture [`DescribeChannelFlowOutput`](crate::output::DescribeChannelFlowOutput).
    pub fn builder() -> crate::output::describe_channel_flow_output::Builder {
        crate::output::describe_channel_flow_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeChannelBanOutput {
    /// <p>The details of the ban.</p>
    #[doc(hidden)]
    pub channel_ban: std::option::Option<crate::model::ChannelBan>,
}
impl DescribeChannelBanOutput {
    /// <p>The details of the ban.</p>
    pub fn channel_ban(&self) -> std::option::Option<&crate::model::ChannelBan> {
        self.channel_ban.as_ref()
    }
}
/// See [`DescribeChannelBanOutput`](crate::output::DescribeChannelBanOutput).
pub mod describe_channel_ban_output {

    /// A builder for [`DescribeChannelBanOutput`](crate::output::DescribeChannelBanOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_ban: std::option::Option<crate::model::ChannelBan>,
    }
    impl Builder {
        /// <p>The details of the ban.</p>
        pub fn channel_ban(mut self, input: crate::model::ChannelBan) -> Self {
            self.channel_ban = Some(input);
            self
        }
        /// <p>The details of the ban.</p>
        pub fn set_channel_ban(
            mut self,
            input: std::option::Option<crate::model::ChannelBan>,
        ) -> Self {
            self.channel_ban = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeChannelBanOutput`](crate::output::DescribeChannelBanOutput).
        pub fn build(self) -> crate::output::DescribeChannelBanOutput {
            crate::output::DescribeChannelBanOutput {
                channel_ban: self.channel_ban,
            }
        }
    }
}
impl DescribeChannelBanOutput {
    /// Creates a new builder-style object to manufacture [`DescribeChannelBanOutput`](crate::output::DescribeChannelBanOutput).
    pub fn builder() -> crate::output::describe_channel_ban_output::Builder {
        crate::output::describe_channel_ban_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeChannelOutput {
    /// <p>The channel details.</p>
    #[doc(hidden)]
    pub channel: std::option::Option<crate::model::Channel>,
}
impl DescribeChannelOutput {
    /// <p>The channel details.</p>
    pub fn channel(&self) -> std::option::Option<&crate::model::Channel> {
        self.channel.as_ref()
    }
}
/// See [`DescribeChannelOutput`](crate::output::DescribeChannelOutput).
pub mod describe_channel_output {

    /// A builder for [`DescribeChannelOutput`](crate::output::DescribeChannelOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel: std::option::Option<crate::model::Channel>,
    }
    impl Builder {
        /// <p>The channel details.</p>
        pub fn channel(mut self, input: crate::model::Channel) -> Self {
            self.channel = Some(input);
            self
        }
        /// <p>The channel details.</p>
        pub fn set_channel(mut self, input: std::option::Option<crate::model::Channel>) -> Self {
            self.channel = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeChannelOutput`](crate::output::DescribeChannelOutput).
        pub fn build(self) -> crate::output::DescribeChannelOutput {
            crate::output::DescribeChannelOutput {
                channel: self.channel,
            }
        }
    }
}
impl DescribeChannelOutput {
    /// Creates a new builder-style object to manufacture [`DescribeChannelOutput`](crate::output::DescribeChannelOutput).
    pub fn builder() -> crate::output::describe_channel_output::Builder {
        crate::output::describe_channel_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteChannelModeratorOutput {}
/// See [`DeleteChannelModeratorOutput`](crate::output::DeleteChannelModeratorOutput).
pub mod delete_channel_moderator_output {

    /// A builder for [`DeleteChannelModeratorOutput`](crate::output::DeleteChannelModeratorOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteChannelModeratorOutput`](crate::output::DeleteChannelModeratorOutput).
        pub fn build(self) -> crate::output::DeleteChannelModeratorOutput {
            crate::output::DeleteChannelModeratorOutput {}
        }
    }
}
impl DeleteChannelModeratorOutput {
    /// Creates a new builder-style object to manufacture [`DeleteChannelModeratorOutput`](crate::output::DeleteChannelModeratorOutput).
    pub fn builder() -> crate::output::delete_channel_moderator_output::Builder {
        crate::output::delete_channel_moderator_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteChannelMessageOutput {}
/// See [`DeleteChannelMessageOutput`](crate::output::DeleteChannelMessageOutput).
pub mod delete_channel_message_output {

    /// A builder for [`DeleteChannelMessageOutput`](crate::output::DeleteChannelMessageOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteChannelMessageOutput`](crate::output::DeleteChannelMessageOutput).
        pub fn build(self) -> crate::output::DeleteChannelMessageOutput {
            crate::output::DeleteChannelMessageOutput {}
        }
    }
}
impl DeleteChannelMessageOutput {
    /// Creates a new builder-style object to manufacture [`DeleteChannelMessageOutput`](crate::output::DeleteChannelMessageOutput).
    pub fn builder() -> crate::output::delete_channel_message_output::Builder {
        crate::output::delete_channel_message_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteChannelMembershipOutput {}
/// See [`DeleteChannelMembershipOutput`](crate::output::DeleteChannelMembershipOutput).
pub mod delete_channel_membership_output {

    /// A builder for [`DeleteChannelMembershipOutput`](crate::output::DeleteChannelMembershipOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteChannelMembershipOutput`](crate::output::DeleteChannelMembershipOutput).
        pub fn build(self) -> crate::output::DeleteChannelMembershipOutput {
            crate::output::DeleteChannelMembershipOutput {}
        }
    }
}
impl DeleteChannelMembershipOutput {
    /// Creates a new builder-style object to manufacture [`DeleteChannelMembershipOutput`](crate::output::DeleteChannelMembershipOutput).
    pub fn builder() -> crate::output::delete_channel_membership_output::Builder {
        crate::output::delete_channel_membership_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteChannelFlowOutput {}
/// See [`DeleteChannelFlowOutput`](crate::output::DeleteChannelFlowOutput).
pub mod delete_channel_flow_output {

    /// A builder for [`DeleteChannelFlowOutput`](crate::output::DeleteChannelFlowOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteChannelFlowOutput`](crate::output::DeleteChannelFlowOutput).
        pub fn build(self) -> crate::output::DeleteChannelFlowOutput {
            crate::output::DeleteChannelFlowOutput {}
        }
    }
}
impl DeleteChannelFlowOutput {
    /// Creates a new builder-style object to manufacture [`DeleteChannelFlowOutput`](crate::output::DeleteChannelFlowOutput).
    pub fn builder() -> crate::output::delete_channel_flow_output::Builder {
        crate::output::delete_channel_flow_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteChannelBanOutput {}
/// See [`DeleteChannelBanOutput`](crate::output::DeleteChannelBanOutput).
pub mod delete_channel_ban_output {

    /// A builder for [`DeleteChannelBanOutput`](crate::output::DeleteChannelBanOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteChannelBanOutput`](crate::output::DeleteChannelBanOutput).
        pub fn build(self) -> crate::output::DeleteChannelBanOutput {
            crate::output::DeleteChannelBanOutput {}
        }
    }
}
impl DeleteChannelBanOutput {
    /// Creates a new builder-style object to manufacture [`DeleteChannelBanOutput`](crate::output::DeleteChannelBanOutput).
    pub fn builder() -> crate::output::delete_channel_ban_output::Builder {
        crate::output::delete_channel_ban_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteChannelOutput {}
/// See [`DeleteChannelOutput`](crate::output::DeleteChannelOutput).
pub mod delete_channel_output {

    /// A builder for [`DeleteChannelOutput`](crate::output::DeleteChannelOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteChannelOutput`](crate::output::DeleteChannelOutput).
        pub fn build(self) -> crate::output::DeleteChannelOutput {
            crate::output::DeleteChannelOutput {}
        }
    }
}
impl DeleteChannelOutput {
    /// Creates a new builder-style object to manufacture [`DeleteChannelOutput`](crate::output::DeleteChannelOutput).
    pub fn builder() -> crate::output::delete_channel_output::Builder {
        crate::output::delete_channel_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateChannelModeratorOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The ARNs of the channel and the moderator.</p>
    #[doc(hidden)]
    pub channel_moderator: std::option::Option<crate::model::Identity>,
}
impl CreateChannelModeratorOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The ARNs of the channel and the moderator.</p>
    pub fn channel_moderator(&self) -> std::option::Option<&crate::model::Identity> {
        self.channel_moderator.as_ref()
    }
}
/// See [`CreateChannelModeratorOutput`](crate::output::CreateChannelModeratorOutput).
pub mod create_channel_moderator_output {

    /// A builder for [`CreateChannelModeratorOutput`](crate::output::CreateChannelModeratorOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) channel_moderator: std::option::Option<crate::model::Identity>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The ARNs of the channel and the moderator.</p>
        pub fn channel_moderator(mut self, input: crate::model::Identity) -> Self {
            self.channel_moderator = Some(input);
            self
        }
        /// <p>The ARNs of the channel and the moderator.</p>
        pub fn set_channel_moderator(
            mut self,
            input: std::option::Option<crate::model::Identity>,
        ) -> Self {
            self.channel_moderator = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateChannelModeratorOutput`](crate::output::CreateChannelModeratorOutput).
        pub fn build(self) -> crate::output::CreateChannelModeratorOutput {
            crate::output::CreateChannelModeratorOutput {
                channel_arn: self.channel_arn,
                channel_moderator: self.channel_moderator,
            }
        }
    }
}
impl CreateChannelModeratorOutput {
    /// Creates a new builder-style object to manufacture [`CreateChannelModeratorOutput`](crate::output::CreateChannelModeratorOutput).
    pub fn builder() -> crate::output::create_channel_moderator_output::Builder {
        crate::output::create_channel_moderator_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateChannelMembershipOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The ARN and metadata of the member being added.</p>
    #[doc(hidden)]
    pub member: std::option::Option<crate::model::Identity>,
    /// <p>The ID of the SubChannel in the response.</p>
    #[doc(hidden)]
    pub sub_channel_id: std::option::Option<std::string::String>,
}
impl CreateChannelMembershipOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The ARN and metadata of the member being added.</p>
    pub fn member(&self) -> std::option::Option<&crate::model::Identity> {
        self.member.as_ref()
    }
    /// <p>The ID of the SubChannel in the response.</p>
    pub fn sub_channel_id(&self) -> std::option::Option<&str> {
        self.sub_channel_id.as_deref()
    }
}
/// See [`CreateChannelMembershipOutput`](crate::output::CreateChannelMembershipOutput).
pub mod create_channel_membership_output {

    /// A builder for [`CreateChannelMembershipOutput`](crate::output::CreateChannelMembershipOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) member: std::option::Option<crate::model::Identity>,
        pub(crate) sub_channel_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The ARN and metadata of the member being added.</p>
        pub fn member(mut self, input: crate::model::Identity) -> Self {
            self.member = Some(input);
            self
        }
        /// <p>The ARN and metadata of the member being added.</p>
        pub fn set_member(mut self, input: std::option::Option<crate::model::Identity>) -> Self {
            self.member = input;
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn sub_channel_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.sub_channel_id = Some(input.into());
            self
        }
        /// <p>The ID of the SubChannel in the response.</p>
        pub fn set_sub_channel_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.sub_channel_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateChannelMembershipOutput`](crate::output::CreateChannelMembershipOutput).
        pub fn build(self) -> crate::output::CreateChannelMembershipOutput {
            crate::output::CreateChannelMembershipOutput {
                channel_arn: self.channel_arn,
                member: self.member,
                sub_channel_id: self.sub_channel_id,
            }
        }
    }
}
impl CreateChannelMembershipOutput {
    /// Creates a new builder-style object to manufacture [`CreateChannelMembershipOutput`](crate::output::CreateChannelMembershipOutput).
    pub fn builder() -> crate::output::create_channel_membership_output::Builder {
        crate::output::create_channel_membership_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateChannelFlowOutput {
    /// <p>The ARN of the channel flow.</p>
    #[doc(hidden)]
    pub channel_flow_arn: std::option::Option<std::string::String>,
}
impl CreateChannelFlowOutput {
    /// <p>The ARN of the channel flow.</p>
    pub fn channel_flow_arn(&self) -> std::option::Option<&str> {
        self.channel_flow_arn.as_deref()
    }
}
/// See [`CreateChannelFlowOutput`](crate::output::CreateChannelFlowOutput).
pub mod create_channel_flow_output {

    /// A builder for [`CreateChannelFlowOutput`](crate::output::CreateChannelFlowOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_flow_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel flow.</p>
        pub fn channel_flow_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_flow_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel flow.</p>
        pub fn set_channel_flow_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.channel_flow_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateChannelFlowOutput`](crate::output::CreateChannelFlowOutput).
        pub fn build(self) -> crate::output::CreateChannelFlowOutput {
            crate::output::CreateChannelFlowOutput {
                channel_flow_arn: self.channel_flow_arn,
            }
        }
    }
}
impl CreateChannelFlowOutput {
    /// Creates a new builder-style object to manufacture [`CreateChannelFlowOutput`](crate::output::CreateChannelFlowOutput).
    pub fn builder() -> crate::output::create_channel_flow_output::Builder {
        crate::output::create_channel_flow_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateChannelBanOutput {
    /// <p>The ARN of the response to the ban request.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The <code>ChannelArn</code> and <code>BannedIdentity</code> of the member in the ban response.</p>
    #[doc(hidden)]
    pub member: std::option::Option<crate::model::Identity>,
}
impl CreateChannelBanOutput {
    /// <p>The ARN of the response to the ban request.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The <code>ChannelArn</code> and <code>BannedIdentity</code> of the member in the ban response.</p>
    pub fn member(&self) -> std::option::Option<&crate::model::Identity> {
        self.member.as_ref()
    }
}
/// See [`CreateChannelBanOutput`](crate::output::CreateChannelBanOutput).
pub mod create_channel_ban_output {

    /// A builder for [`CreateChannelBanOutput`](crate::output::CreateChannelBanOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) member: std::option::Option<crate::model::Identity>,
    }
    impl Builder {
        /// <p>The ARN of the response to the ban request.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the response to the ban request.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The <code>ChannelArn</code> and <code>BannedIdentity</code> of the member in the ban response.</p>
        pub fn member(mut self, input: crate::model::Identity) -> Self {
            self.member = Some(input);
            self
        }
        /// <p>The <code>ChannelArn</code> and <code>BannedIdentity</code> of the member in the ban response.</p>
        pub fn set_member(mut self, input: std::option::Option<crate::model::Identity>) -> Self {
            self.member = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateChannelBanOutput`](crate::output::CreateChannelBanOutput).
        pub fn build(self) -> crate::output::CreateChannelBanOutput {
            crate::output::CreateChannelBanOutput {
                channel_arn: self.channel_arn,
                member: self.member,
            }
        }
    }
}
impl CreateChannelBanOutput {
    /// Creates a new builder-style object to manufacture [`CreateChannelBanOutput`](crate::output::CreateChannelBanOutput).
    pub fn builder() -> crate::output::create_channel_ban_output::Builder {
        crate::output::create_channel_ban_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateChannelOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
}
impl CreateChannelOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
}
/// See [`CreateChannelOutput`](crate::output::CreateChannelOutput).
pub mod create_channel_output {

    /// A builder for [`CreateChannelOutput`](crate::output::CreateChannelOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateChannelOutput`](crate::output::CreateChannelOutput).
        pub fn build(self) -> crate::output::CreateChannelOutput {
            crate::output::CreateChannelOutput {
                channel_arn: self.channel_arn,
            }
        }
    }
}
impl CreateChannelOutput {
    /// Creates a new builder-style object to manufacture [`CreateChannelOutput`](crate::output::CreateChannelOutput).
    pub fn builder() -> crate::output::create_channel_output::Builder {
        crate::output::create_channel_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ChannelFlowCallbackOutput {
    /// <p>The ARN of the channel.</p>
    #[doc(hidden)]
    pub channel_arn: std::option::Option<std::string::String>,
    /// <p>The call back ID passed in the request.</p>
    #[doc(hidden)]
    pub callback_id: std::option::Option<std::string::String>,
}
impl ChannelFlowCallbackOutput {
    /// <p>The ARN of the channel.</p>
    pub fn channel_arn(&self) -> std::option::Option<&str> {
        self.channel_arn.as_deref()
    }
    /// <p>The call back ID passed in the request.</p>
    pub fn callback_id(&self) -> std::option::Option<&str> {
        self.callback_id.as_deref()
    }
}
/// See [`ChannelFlowCallbackOutput`](crate::output::ChannelFlowCallbackOutput).
pub mod channel_flow_callback_output {

    /// A builder for [`ChannelFlowCallbackOutput`](crate::output::ChannelFlowCallbackOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) channel_arn: std::option::Option<std::string::String>,
        pub(crate) callback_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ARN of the channel.</p>
        pub fn channel_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.channel_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the channel.</p>
        pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.channel_arn = input;
            self
        }
        /// <p>The call back ID passed in the request.</p>
        pub fn callback_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.callback_id = Some(input.into());
            self
        }
        /// <p>The call back ID passed in the request.</p>
        pub fn set_callback_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.callback_id = input;
            self
        }
        /// Consumes the builder and constructs a [`ChannelFlowCallbackOutput`](crate::output::ChannelFlowCallbackOutput).
        pub fn build(self) -> crate::output::ChannelFlowCallbackOutput {
            crate::output::ChannelFlowCallbackOutput {
                channel_arn: self.channel_arn,
                callback_id: self.callback_id,
            }
        }
    }
}
impl ChannelFlowCallbackOutput {
    /// Creates a new builder-style object to manufacture [`ChannelFlowCallbackOutput`](crate::output::ChannelFlowCallbackOutput).
    pub fn builder() -> crate::output::channel_flow_callback_output::Builder {
        crate::output::channel_flow_callback_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchCreateChannelMembershipOutput {
    /// <p>The list of channel memberships in the response.</p>
    #[doc(hidden)]
    pub batch_channel_memberships: std::option::Option<crate::model::BatchChannelMemberships>,
    /// <p>If the action fails for one or more of the memberships in the request, a list of the memberships is returned, along with error codes and error messages.</p>
    #[doc(hidden)]
    pub errors: std::option::Option<std::vec::Vec<crate::model::BatchCreateChannelMembershipError>>,
}
impl BatchCreateChannelMembershipOutput {
    /// <p>The list of channel memberships in the response.</p>
    pub fn batch_channel_memberships(
        &self,
    ) -> std::option::Option<&crate::model::BatchChannelMemberships> {
        self.batch_channel_memberships.as_ref()
    }
    /// <p>If the action fails for one or more of the memberships in the request, a list of the memberships is returned, along with error codes and error messages.</p>
    pub fn errors(
        &self,
    ) -> std::option::Option<&[crate::model::BatchCreateChannelMembershipError]> {
        self.errors.as_deref()
    }
}
/// See [`BatchCreateChannelMembershipOutput`](crate::output::BatchCreateChannelMembershipOutput).
pub mod batch_create_channel_membership_output {

    /// A builder for [`BatchCreateChannelMembershipOutput`](crate::output::BatchCreateChannelMembershipOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) batch_channel_memberships:
            std::option::Option<crate::model::BatchChannelMemberships>,
        pub(crate) errors:
            std::option::Option<std::vec::Vec<crate::model::BatchCreateChannelMembershipError>>,
    }
    impl Builder {
        /// <p>The list of channel memberships in the response.</p>
        pub fn batch_channel_memberships(
            mut self,
            input: crate::model::BatchChannelMemberships,
        ) -> Self {
            self.batch_channel_memberships = Some(input);
            self
        }
        /// <p>The list of channel memberships in the response.</p>
        pub fn set_batch_channel_memberships(
            mut self,
            input: std::option::Option<crate::model::BatchChannelMemberships>,
        ) -> Self {
            self.batch_channel_memberships = input;
            self
        }
        /// Appends an item to `errors`.
        ///
        /// To override the contents of this collection use [`set_errors`](Self::set_errors).
        ///
        /// <p>If the action fails for one or more of the memberships in the request, a list of the memberships is returned, along with error codes and error messages.</p>
        pub fn errors(mut self, input: crate::model::BatchCreateChannelMembershipError) -> Self {
            let mut v = self.errors.unwrap_or_default();
            v.push(input);
            self.errors = Some(v);
            self
        }
        /// <p>If the action fails for one or more of the memberships in the request, a list of the memberships is returned, along with error codes and error messages.</p>
        pub fn set_errors(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::BatchCreateChannelMembershipError>,
            >,
        ) -> Self {
            self.errors = input;
            self
        }
        /// Consumes the builder and constructs a [`BatchCreateChannelMembershipOutput`](crate::output::BatchCreateChannelMembershipOutput).
        pub fn build(self) -> crate::output::BatchCreateChannelMembershipOutput {
            crate::output::BatchCreateChannelMembershipOutput {
                batch_channel_memberships: self.batch_channel_memberships,
                errors: self.errors,
            }
        }
    }
}
impl BatchCreateChannelMembershipOutput {
    /// Creates a new builder-style object to manufacture [`BatchCreateChannelMembershipOutput`](crate::output::BatchCreateChannelMembershipOutput).
    pub fn builder() -> crate::output::batch_create_channel_membership_output::Builder {
        crate::output::batch_create_channel_membership_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AssociateChannelFlowOutput {}
/// See [`AssociateChannelFlowOutput`](crate::output::AssociateChannelFlowOutput).
pub mod associate_channel_flow_output {

    /// A builder for [`AssociateChannelFlowOutput`](crate::output::AssociateChannelFlowOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`AssociateChannelFlowOutput`](crate::output::AssociateChannelFlowOutput).
        pub fn build(self) -> crate::output::AssociateChannelFlowOutput {
            crate::output::AssociateChannelFlowOutput {}
        }
    }
}
impl AssociateChannelFlowOutput {
    /// Creates a new builder-style object to manufacture [`AssociateChannelFlowOutput`](crate::output::AssociateChannelFlowOutput).
    pub fn builder() -> crate::output::associate_channel_flow_output::Builder {
        crate::output::associate_channel_flow_output::Builder::default()
    }
}