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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchUsersOutput {
    /// <p>The users that meet the specified set of filter criteria, in sort order.</p>
    pub users: std::option::Option<std::vec::Vec<crate::model::UserData>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The total number of users returned.</p>
    pub total_count: std::option::Option<i32>,
}
impl SearchUsersOutput {
    /// <p>The users that meet the specified set of filter criteria, in sort order.</p>
    pub fn users(&self) -> std::option::Option<&[crate::model::UserData]> {
        self.users.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The total number of users returned.</p>
    pub fn total_count(&self) -> std::option::Option<i32> {
        self.total_count
    }
}
impl std::fmt::Debug for SearchUsersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchUsersOutput");
        formatter.field("users", &self.users);
        formatter.field("next_token", &self.next_token);
        formatter.field("total_count", &self.total_count);
        formatter.finish()
    }
}
/// See [`SearchUsersOutput`](crate::output::SearchUsersOutput)
pub mod search_users_output {
    /// A builder for [`SearchUsersOutput`](crate::output::SearchUsersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) users: std::option::Option<std::vec::Vec<crate::model::UserData>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) total_count: std::option::Option<i32>,
    }
    impl Builder {
        /// Appends an item to `users`.
        ///
        /// To override the contents of this collection use [`set_users`](Self::set_users).
        ///
        /// <p>The users that meet the specified set of filter criteria, in sort order.</p>
        pub fn users(mut self, input: impl Into<crate::model::UserData>) -> Self {
            let mut v = self.users.unwrap_or_default();
            v.push(input.into());
            self.users = Some(v);
            self
        }
        /// <p>The users that meet the specified set of filter criteria, in sort order.</p>
        pub fn set_users(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::UserData>>,
        ) -> Self {
            self.users = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>The total number of users returned.</p>
        pub fn total_count(mut self, input: i32) -> Self {
            self.total_count = Some(input);
            self
        }
        /// <p>The total number of users returned.</p>
        pub fn set_total_count(mut self, input: std::option::Option<i32>) -> Self {
            self.total_count = input;
            self
        }
        /// Consumes the builder and constructs a [`SearchUsersOutput`](crate::output::SearchUsersOutput)
        pub fn build(self) -> crate::output::SearchUsersOutput {
            crate::output::SearchUsersOutput {
                users: self.users,
                next_token: self.next_token,
                total_count: self.total_count,
            }
        }
    }
}
impl SearchUsersOutput {
    /// Creates a new builder-style object to manufacture [`SearchUsersOutput`](crate::output::SearchUsersOutput)
    pub fn builder() -> crate::output::search_users_output::Builder {
        crate::output::search_users_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchSkillGroupsOutput {
    /// <p>The skill groups that meet the filter criteria, in sort order.</p>
    pub skill_groups: std::option::Option<std::vec::Vec<crate::model::SkillGroupData>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The total number of skill groups returned.</p>
    pub total_count: std::option::Option<i32>,
}
impl SearchSkillGroupsOutput {
    /// <p>The skill groups that meet the filter criteria, in sort order.</p>
    pub fn skill_groups(&self) -> std::option::Option<&[crate::model::SkillGroupData]> {
        self.skill_groups.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The total number of skill groups returned.</p>
    pub fn total_count(&self) -> std::option::Option<i32> {
        self.total_count
    }
}
impl std::fmt::Debug for SearchSkillGroupsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchSkillGroupsOutput");
        formatter.field("skill_groups", &self.skill_groups);
        formatter.field("next_token", &self.next_token);
        formatter.field("total_count", &self.total_count);
        formatter.finish()
    }
}
/// See [`SearchSkillGroupsOutput`](crate::output::SearchSkillGroupsOutput)
pub mod search_skill_groups_output {
    /// A builder for [`SearchSkillGroupsOutput`](crate::output::SearchSkillGroupsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) skill_groups: std::option::Option<std::vec::Vec<crate::model::SkillGroupData>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) total_count: std::option::Option<i32>,
    }
    impl Builder {
        /// Appends an item to `skill_groups`.
        ///
        /// To override the contents of this collection use [`set_skill_groups`](Self::set_skill_groups).
        ///
        /// <p>The skill groups that meet the filter criteria, in sort order.</p>
        pub fn skill_groups(mut self, input: impl Into<crate::model::SkillGroupData>) -> Self {
            let mut v = self.skill_groups.unwrap_or_default();
            v.push(input.into());
            self.skill_groups = Some(v);
            self
        }
        /// <p>The skill groups that meet the filter criteria, in sort order.</p>
        pub fn set_skill_groups(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::SkillGroupData>>,
        ) -> Self {
            self.skill_groups = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>The total number of skill groups returned.</p>
        pub fn total_count(mut self, input: i32) -> Self {
            self.total_count = Some(input);
            self
        }
        /// <p>The total number of skill groups returned.</p>
        pub fn set_total_count(mut self, input: std::option::Option<i32>) -> Self {
            self.total_count = input;
            self
        }
        /// Consumes the builder and constructs a [`SearchSkillGroupsOutput`](crate::output::SearchSkillGroupsOutput)
        pub fn build(self) -> crate::output::SearchSkillGroupsOutput {
            crate::output::SearchSkillGroupsOutput {
                skill_groups: self.skill_groups,
                next_token: self.next_token,
                total_count: self.total_count,
            }
        }
    }
}
impl SearchSkillGroupsOutput {
    /// Creates a new builder-style object to manufacture [`SearchSkillGroupsOutput`](crate::output::SearchSkillGroupsOutput)
    pub fn builder() -> crate::output::search_skill_groups_output::Builder {
        crate::output::search_skill_groups_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchRoomsOutput {
    /// <p>The rooms that meet the specified set of filter criteria, in sort order.</p>
    pub rooms: std::option::Option<std::vec::Vec<crate::model::RoomData>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The total number of rooms returned.</p>
    pub total_count: std::option::Option<i32>,
}
impl SearchRoomsOutput {
    /// <p>The rooms that meet the specified set of filter criteria, in sort order.</p>
    pub fn rooms(&self) -> std::option::Option<&[crate::model::RoomData]> {
        self.rooms.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The total number of rooms returned.</p>
    pub fn total_count(&self) -> std::option::Option<i32> {
        self.total_count
    }
}
impl std::fmt::Debug for SearchRoomsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchRoomsOutput");
        formatter.field("rooms", &self.rooms);
        formatter.field("next_token", &self.next_token);
        formatter.field("total_count", &self.total_count);
        formatter.finish()
    }
}
/// See [`SearchRoomsOutput`](crate::output::SearchRoomsOutput)
pub mod search_rooms_output {
    /// A builder for [`SearchRoomsOutput`](crate::output::SearchRoomsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) rooms: std::option::Option<std::vec::Vec<crate::model::RoomData>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) total_count: std::option::Option<i32>,
    }
    impl Builder {
        /// Appends an item to `rooms`.
        ///
        /// To override the contents of this collection use [`set_rooms`](Self::set_rooms).
        ///
        /// <p>The rooms that meet the specified set of filter criteria, in sort order.</p>
        pub fn rooms(mut self, input: impl Into<crate::model::RoomData>) -> Self {
            let mut v = self.rooms.unwrap_or_default();
            v.push(input.into());
            self.rooms = Some(v);
            self
        }
        /// <p>The rooms that meet the specified set of filter criteria, in sort order.</p>
        pub fn set_rooms(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RoomData>>,
        ) -> Self {
            self.rooms = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>The total number of rooms returned.</p>
        pub fn total_count(mut self, input: i32) -> Self {
            self.total_count = Some(input);
            self
        }
        /// <p>The total number of rooms returned.</p>
        pub fn set_total_count(mut self, input: std::option::Option<i32>) -> Self {
            self.total_count = input;
            self
        }
        /// Consumes the builder and constructs a [`SearchRoomsOutput`](crate::output::SearchRoomsOutput)
        pub fn build(self) -> crate::output::SearchRoomsOutput {
            crate::output::SearchRoomsOutput {
                rooms: self.rooms,
                next_token: self.next_token,
                total_count: self.total_count,
            }
        }
    }
}
impl SearchRoomsOutput {
    /// Creates a new builder-style object to manufacture [`SearchRoomsOutput`](crate::output::SearchRoomsOutput)
    pub fn builder() -> crate::output::search_rooms_output::Builder {
        crate::output::search_rooms_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchProfilesOutput {
    /// <p>The profiles that meet the specified set of filter criteria, in sort order.</p>
    pub profiles: std::option::Option<std::vec::Vec<crate::model::ProfileData>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The total number of room profiles returned.</p>
    pub total_count: std::option::Option<i32>,
}
impl SearchProfilesOutput {
    /// <p>The profiles that meet the specified set of filter criteria, in sort order.</p>
    pub fn profiles(&self) -> std::option::Option<&[crate::model::ProfileData]> {
        self.profiles.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The total number of room profiles returned.</p>
    pub fn total_count(&self) -> std::option::Option<i32> {
        self.total_count
    }
}
impl std::fmt::Debug for SearchProfilesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchProfilesOutput");
        formatter.field("profiles", &self.profiles);
        formatter.field("next_token", &self.next_token);
        formatter.field("total_count", &self.total_count);
        formatter.finish()
    }
}
/// See [`SearchProfilesOutput`](crate::output::SearchProfilesOutput)
pub mod search_profiles_output {
    /// A builder for [`SearchProfilesOutput`](crate::output::SearchProfilesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) profiles: std::option::Option<std::vec::Vec<crate::model::ProfileData>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) total_count: std::option::Option<i32>,
    }
    impl Builder {
        /// Appends an item to `profiles`.
        ///
        /// To override the contents of this collection use [`set_profiles`](Self::set_profiles).
        ///
        /// <p>The profiles that meet the specified set of filter criteria, in sort order.</p>
        pub fn profiles(mut self, input: impl Into<crate::model::ProfileData>) -> Self {
            let mut v = self.profiles.unwrap_or_default();
            v.push(input.into());
            self.profiles = Some(v);
            self
        }
        /// <p>The profiles that meet the specified set of filter criteria, in sort order.</p>
        pub fn set_profiles(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ProfileData>>,
        ) -> Self {
            self.profiles = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>The total number of room profiles returned.</p>
        pub fn total_count(mut self, input: i32) -> Self {
            self.total_count = Some(input);
            self
        }
        /// <p>The total number of room profiles returned.</p>
        pub fn set_total_count(mut self, input: std::option::Option<i32>) -> Self {
            self.total_count = input;
            self
        }
        /// Consumes the builder and constructs a [`SearchProfilesOutput`](crate::output::SearchProfilesOutput)
        pub fn build(self) -> crate::output::SearchProfilesOutput {
            crate::output::SearchProfilesOutput {
                profiles: self.profiles,
                next_token: self.next_token,
                total_count: self.total_count,
            }
        }
    }
}
impl SearchProfilesOutput {
    /// Creates a new builder-style object to manufacture [`SearchProfilesOutput`](crate::output::SearchProfilesOutput)
    pub fn builder() -> crate::output::search_profiles_output::Builder {
        crate::output::search_profiles_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchNetworkProfilesOutput {
    /// <p>The network profiles that meet the specified set of filter criteria, in sort order. It
    /// is a list of NetworkProfileData objects. </p>
    pub network_profiles: std::option::Option<std::vec::Vec<crate::model::NetworkProfileData>>,
    /// <p>An optional token returned from a prior request. Use this token for pagination of
    /// results from this action. If this parameter is specified, the response includes only
    /// results beyond the token, up to the value specified by MaxResults.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The total number of network profiles returned.</p>
    pub total_count: std::option::Option<i32>,
}
impl SearchNetworkProfilesOutput {
    /// <p>The network profiles that meet the specified set of filter criteria, in sort order. It
    /// is a list of NetworkProfileData objects. </p>
    pub fn network_profiles(&self) -> std::option::Option<&[crate::model::NetworkProfileData]> {
        self.network_profiles.as_deref()
    }
    /// <p>An optional token returned from a prior request. Use this token for pagination of
    /// results from this action. If this parameter is specified, the response includes only
    /// results beyond the token, up to the value specified by MaxResults.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The total number of network profiles returned.</p>
    pub fn total_count(&self) -> std::option::Option<i32> {
        self.total_count
    }
}
impl std::fmt::Debug for SearchNetworkProfilesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchNetworkProfilesOutput");
        formatter.field("network_profiles", &self.network_profiles);
        formatter.field("next_token", &self.next_token);
        formatter.field("total_count", &self.total_count);
        formatter.finish()
    }
}
/// See [`SearchNetworkProfilesOutput`](crate::output::SearchNetworkProfilesOutput)
pub mod search_network_profiles_output {
    /// A builder for [`SearchNetworkProfilesOutput`](crate::output::SearchNetworkProfilesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) network_profiles:
            std::option::Option<std::vec::Vec<crate::model::NetworkProfileData>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) total_count: std::option::Option<i32>,
    }
    impl Builder {
        /// Appends an item to `network_profiles`.
        ///
        /// To override the contents of this collection use [`set_network_profiles`](Self::set_network_profiles).
        ///
        /// <p>The network profiles that meet the specified set of filter criteria, in sort order. It
        /// is a list of NetworkProfileData objects. </p>
        pub fn network_profiles(
            mut self,
            input: impl Into<crate::model::NetworkProfileData>,
        ) -> Self {
            let mut v = self.network_profiles.unwrap_or_default();
            v.push(input.into());
            self.network_profiles = Some(v);
            self
        }
        /// <p>The network profiles that meet the specified set of filter criteria, in sort order. It
        /// is a list of NetworkProfileData objects. </p>
        pub fn set_network_profiles(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::NetworkProfileData>>,
        ) -> Self {
            self.network_profiles = input;
            self
        }
        /// <p>An optional token returned from a prior request. Use this token for pagination of
        /// results from this action. If this parameter is specified, the response includes only
        /// results beyond the token, up to the value specified by MaxResults.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An optional token returned from a prior request. Use this token for pagination of
        /// results from this action. If this parameter is specified, the response includes only
        /// results beyond the token, up to the value specified by MaxResults.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>The total number of network profiles returned.</p>
        pub fn total_count(mut self, input: i32) -> Self {
            self.total_count = Some(input);
            self
        }
        /// <p>The total number of network profiles returned.</p>
        pub fn set_total_count(mut self, input: std::option::Option<i32>) -> Self {
            self.total_count = input;
            self
        }
        /// Consumes the builder and constructs a [`SearchNetworkProfilesOutput`](crate::output::SearchNetworkProfilesOutput)
        pub fn build(self) -> crate::output::SearchNetworkProfilesOutput {
            crate::output::SearchNetworkProfilesOutput {
                network_profiles: self.network_profiles,
                next_token: self.next_token,
                total_count: self.total_count,
            }
        }
    }
}
impl SearchNetworkProfilesOutput {
    /// Creates a new builder-style object to manufacture [`SearchNetworkProfilesOutput`](crate::output::SearchNetworkProfilesOutput)
    pub fn builder() -> crate::output::search_network_profiles_output::Builder {
        crate::output::search_network_profiles_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchDevicesOutput {
    /// <p>The devices that meet the specified set of filter criteria, in sort order.</p>
    pub devices: std::option::Option<std::vec::Vec<crate::model::DeviceData>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The total number of devices returned.</p>
    pub total_count: std::option::Option<i32>,
}
impl SearchDevicesOutput {
    /// <p>The devices that meet the specified set of filter criteria, in sort order.</p>
    pub fn devices(&self) -> std::option::Option<&[crate::model::DeviceData]> {
        self.devices.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The total number of devices returned.</p>
    pub fn total_count(&self) -> std::option::Option<i32> {
        self.total_count
    }
}
impl std::fmt::Debug for SearchDevicesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchDevicesOutput");
        formatter.field("devices", &self.devices);
        formatter.field("next_token", &self.next_token);
        formatter.field("total_count", &self.total_count);
        formatter.finish()
    }
}
/// See [`SearchDevicesOutput`](crate::output::SearchDevicesOutput)
pub mod search_devices_output {
    /// A builder for [`SearchDevicesOutput`](crate::output::SearchDevicesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) devices: std::option::Option<std::vec::Vec<crate::model::DeviceData>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) total_count: std::option::Option<i32>,
    }
    impl Builder {
        /// Appends an item to `devices`.
        ///
        /// To override the contents of this collection use [`set_devices`](Self::set_devices).
        ///
        /// <p>The devices that meet the specified set of filter criteria, in sort order.</p>
        pub fn devices(mut self, input: impl Into<crate::model::DeviceData>) -> Self {
            let mut v = self.devices.unwrap_or_default();
            v.push(input.into());
            self.devices = Some(v);
            self
        }
        /// <p>The devices that meet the specified set of filter criteria, in sort order.</p>
        pub fn set_devices(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DeviceData>>,
        ) -> Self {
            self.devices = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>The total number of devices returned.</p>
        pub fn total_count(mut self, input: i32) -> Self {
            self.total_count = Some(input);
            self
        }
        /// <p>The total number of devices returned.</p>
        pub fn set_total_count(mut self, input: std::option::Option<i32>) -> Self {
            self.total_count = input;
            self
        }
        /// Consumes the builder and constructs a [`SearchDevicesOutput`](crate::output::SearchDevicesOutput)
        pub fn build(self) -> crate::output::SearchDevicesOutput {
            crate::output::SearchDevicesOutput {
                devices: self.devices,
                next_token: self.next_token,
                total_count: self.total_count,
            }
        }
    }
}
impl SearchDevicesOutput {
    /// Creates a new builder-style object to manufacture [`SearchDevicesOutput`](crate::output::SearchDevicesOutput)
    pub fn builder() -> crate::output::search_devices_output::Builder {
        crate::output::search_devices_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchContactsOutput {
    /// <p>The contacts that meet the specified set of filter criteria, in sort order.</p>
    pub contacts: std::option::Option<std::vec::Vec<crate::model::ContactData>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The total number of contacts returned.</p>
    pub total_count: std::option::Option<i32>,
}
impl SearchContactsOutput {
    /// <p>The contacts that meet the specified set of filter criteria, in sort order.</p>
    pub fn contacts(&self) -> std::option::Option<&[crate::model::ContactData]> {
        self.contacts.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The total number of contacts returned.</p>
    pub fn total_count(&self) -> std::option::Option<i32> {
        self.total_count
    }
}
impl std::fmt::Debug for SearchContactsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchContactsOutput");
        formatter.field("contacts", &self.contacts);
        formatter.field("next_token", &self.next_token);
        formatter.field("total_count", &self.total_count);
        formatter.finish()
    }
}
/// See [`SearchContactsOutput`](crate::output::SearchContactsOutput)
pub mod search_contacts_output {
    /// A builder for [`SearchContactsOutput`](crate::output::SearchContactsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) contacts: std::option::Option<std::vec::Vec<crate::model::ContactData>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) total_count: std::option::Option<i32>,
    }
    impl Builder {
        /// Appends an item to `contacts`.
        ///
        /// To override the contents of this collection use [`set_contacts`](Self::set_contacts).
        ///
        /// <p>The contacts that meet the specified set of filter criteria, in sort order.</p>
        pub fn contacts(mut self, input: impl Into<crate::model::ContactData>) -> Self {
            let mut v = self.contacts.unwrap_or_default();
            v.push(input.into());
            self.contacts = Some(v);
            self
        }
        /// <p>The contacts that meet the specified set of filter criteria, in sort order.</p>
        pub fn set_contacts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ContactData>>,
        ) -> Self {
            self.contacts = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>The total number of contacts returned.</p>
        pub fn total_count(mut self, input: i32) -> Self {
            self.total_count = Some(input);
            self
        }
        /// <p>The total number of contacts returned.</p>
        pub fn set_total_count(mut self, input: std::option::Option<i32>) -> Self {
            self.total_count = input;
            self
        }
        /// Consumes the builder and constructs a [`SearchContactsOutput`](crate::output::SearchContactsOutput)
        pub fn build(self) -> crate::output::SearchContactsOutput {
            crate::output::SearchContactsOutput {
                contacts: self.contacts,
                next_token: self.next_token,
                total_count: self.total_count,
            }
        }
    }
}
impl SearchContactsOutput {
    /// Creates a new builder-style object to manufacture [`SearchContactsOutput`](crate::output::SearchContactsOutput)
    pub fn builder() -> crate::output::search_contacts_output::Builder {
        crate::output::search_contacts_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchAddressBooksOutput {
    /// <p>The address books that meet the specified set of filter criteria, in sort
    /// order.</p>
    pub address_books: std::option::Option<std::vec::Vec<crate::model::AddressBookData>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
    /// <p>The total number of address books returned.</p>
    pub total_count: std::option::Option<i32>,
}
impl SearchAddressBooksOutput {
    /// <p>The address books that meet the specified set of filter criteria, in sort
    /// order.</p>
    pub fn address_books(&self) -> std::option::Option<&[crate::model::AddressBookData]> {
        self.address_books.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>The total number of address books returned.</p>
    pub fn total_count(&self) -> std::option::Option<i32> {
        self.total_count
    }
}
impl std::fmt::Debug for SearchAddressBooksOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SearchAddressBooksOutput");
        formatter.field("address_books", &self.address_books);
        formatter.field("next_token", &self.next_token);
        formatter.field("total_count", &self.total_count);
        formatter.finish()
    }
}
/// See [`SearchAddressBooksOutput`](crate::output::SearchAddressBooksOutput)
pub mod search_address_books_output {
    /// A builder for [`SearchAddressBooksOutput`](crate::output::SearchAddressBooksOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) address_books: std::option::Option<std::vec::Vec<crate::model::AddressBookData>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) total_count: std::option::Option<i32>,
    }
    impl Builder {
        /// Appends an item to `address_books`.
        ///
        /// To override the contents of this collection use [`set_address_books`](Self::set_address_books).
        ///
        /// <p>The address books that meet the specified set of filter criteria, in sort
        /// order.</p>
        pub fn address_books(mut self, input: impl Into<crate::model::AddressBookData>) -> Self {
            let mut v = self.address_books.unwrap_or_default();
            v.push(input.into());
            self.address_books = Some(v);
            self
        }
        /// <p>The address books that meet the specified set of filter criteria, in sort
        /// order.</p>
        pub fn set_address_books(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AddressBookData>>,
        ) -> Self {
            self.address_books = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// <p>The total number of address books returned.</p>
        pub fn total_count(mut self, input: i32) -> Self {
            self.total_count = Some(input);
            self
        }
        /// <p>The total number of address books returned.</p>
        pub fn set_total_count(mut self, input: std::option::Option<i32>) -> Self {
            self.total_count = input;
            self
        }
        /// Consumes the builder and constructs a [`SearchAddressBooksOutput`](crate::output::SearchAddressBooksOutput)
        pub fn build(self) -> crate::output::SearchAddressBooksOutput {
            crate::output::SearchAddressBooksOutput {
                address_books: self.address_books,
                next_token: self.next_token,
                total_count: self.total_count,
            }
        }
    }
}
impl SearchAddressBooksOutput {
    /// Creates a new builder-style object to manufacture [`SearchAddressBooksOutput`](crate::output::SearchAddressBooksOutput)
    pub fn builder() -> crate::output::search_address_books_output::Builder {
        crate::output::search_address_books_output::Builder::default()
    }
}

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ResolveRoomOutput {
    /// <p>The ARN of the room from which the skill request was invoked.</p>
    pub room_arn: std::option::Option<std::string::String>,
    /// <p>The name of the room from which the skill request was invoked.</p>
    pub room_name: std::option::Option<std::string::String>,
    /// <p>Response to get the room profile request. Required.</p>
    pub room_skill_parameters: std::option::Option<std::vec::Vec<crate::model::RoomSkillParameter>>,
}
impl ResolveRoomOutput {
    /// <p>The ARN of the room from which the skill request was invoked.</p>
    pub fn room_arn(&self) -> std::option::Option<&str> {
        self.room_arn.as_deref()
    }
    /// <p>The name of the room from which the skill request was invoked.</p>
    pub fn room_name(&self) -> std::option::Option<&str> {
        self.room_name.as_deref()
    }
    /// <p>Response to get the room profile request. Required.</p>
    pub fn room_skill_parameters(
        &self,
    ) -> std::option::Option<&[crate::model::RoomSkillParameter]> {
        self.room_skill_parameters.as_deref()
    }
}
impl std::fmt::Debug for ResolveRoomOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ResolveRoomOutput");
        formatter.field("room_arn", &self.room_arn);
        formatter.field("room_name", &self.room_name);
        formatter.field("room_skill_parameters", &self.room_skill_parameters);
        formatter.finish()
    }
}
/// See [`ResolveRoomOutput`](crate::output::ResolveRoomOutput)
pub mod resolve_room_output {
    /// A builder for [`ResolveRoomOutput`](crate::output::ResolveRoomOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) room_arn: std::option::Option<std::string::String>,
        pub(crate) room_name: std::option::Option<std::string::String>,
        pub(crate) room_skill_parameters:
            std::option::Option<std::vec::Vec<crate::model::RoomSkillParameter>>,
    }
    impl Builder {
        /// <p>The ARN of the room from which the skill request was invoked.</p>
        pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.room_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the room from which the skill request was invoked.</p>
        pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.room_arn = input;
            self
        }
        /// <p>The name of the room from which the skill request was invoked.</p>
        pub fn room_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.room_name = Some(input.into());
            self
        }
        /// <p>The name of the room from which the skill request was invoked.</p>
        pub fn set_room_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.room_name = input;
            self
        }
        /// Appends an item to `room_skill_parameters`.
        ///
        /// To override the contents of this collection use [`set_room_skill_parameters`](Self::set_room_skill_parameters).
        ///
        /// <p>Response to get the room profile request. Required.</p>
        pub fn room_skill_parameters(
            mut self,
            input: impl Into<crate::model::RoomSkillParameter>,
        ) -> Self {
            let mut v = self.room_skill_parameters.unwrap_or_default();
            v.push(input.into());
            self.room_skill_parameters = Some(v);
            self
        }
        /// <p>Response to get the room profile request. Required.</p>
        pub fn set_room_skill_parameters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RoomSkillParameter>>,
        ) -> Self {
            self.room_skill_parameters = input;
            self
        }
        /// Consumes the builder and constructs a [`ResolveRoomOutput`](crate::output::ResolveRoomOutput)
        pub fn build(self) -> crate::output::ResolveRoomOutput {
            crate::output::ResolveRoomOutput {
                room_arn: self.room_arn,
                room_name: self.room_name,
                room_skill_parameters: self.room_skill_parameters,
            }
        }
    }
}
impl ResolveRoomOutput {
    /// Creates a new builder-style object to manufacture [`ResolveRoomOutput`](crate::output::ResolveRoomOutput)
    pub fn builder() -> crate::output::resolve_room_output::Builder {
        crate::output::resolve_room_output::Builder::default()
    }
}

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsOutput {
    /// <p>The tags requested for the specified resource.</p>
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListTagsOutput {
    /// <p>The tags requested for the specified resource.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListTagsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsOutput");
        formatter.field("tags", &self.tags);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListTagsOutput`](crate::output::ListTagsOutput)
pub mod list_tags_output {
    /// A builder for [`ListTagsOutput`](crate::output::ListTagsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags requested for the specified resource.</p>
        pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input.into());
            self.tags = Some(v);
            self
        }
        /// <p>The tags requested for the specified resource.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</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 [`ListTagsOutput`](crate::output::ListTagsOutput)
        pub fn build(self) -> crate::output::ListTagsOutput {
            crate::output::ListTagsOutput {
                tags: self.tags,
                next_token: self.next_token,
            }
        }
    }
}
impl ListTagsOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsOutput`](crate::output::ListTagsOutput)
    pub fn builder() -> crate::output::list_tags_output::Builder {
        crate::output::list_tags_output::Builder::default()
    }
}

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListSkillsOutput {
    /// <p>The list of enabled skills requested. Required.</p>
    pub skill_summaries: std::option::Option<std::vec::Vec<crate::model::SkillSummary>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListSkillsOutput {
    /// <p>The list of enabled skills requested. Required.</p>
    pub fn skill_summaries(&self) -> std::option::Option<&[crate::model::SkillSummary]> {
        self.skill_summaries.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListSkillsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListSkillsOutput");
        formatter.field("skill_summaries", &self.skill_summaries);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListSkillsOutput`](crate::output::ListSkillsOutput)
pub mod list_skills_output {
    /// A builder for [`ListSkillsOutput`](crate::output::ListSkillsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) skill_summaries: std::option::Option<std::vec::Vec<crate::model::SkillSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `skill_summaries`.
        ///
        /// To override the contents of this collection use [`set_skill_summaries`](Self::set_skill_summaries).
        ///
        /// <p>The list of enabled skills requested. Required.</p>
        pub fn skill_summaries(mut self, input: impl Into<crate::model::SkillSummary>) -> Self {
            let mut v = self.skill_summaries.unwrap_or_default();
            v.push(input.into());
            self.skill_summaries = Some(v);
            self
        }
        /// <p>The list of enabled skills requested. Required.</p>
        pub fn set_skill_summaries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::SkillSummary>>,
        ) -> Self {
            self.skill_summaries = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</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 [`ListSkillsOutput`](crate::output::ListSkillsOutput)
        pub fn build(self) -> crate::output::ListSkillsOutput {
            crate::output::ListSkillsOutput {
                skill_summaries: self.skill_summaries,
                next_token: self.next_token,
            }
        }
    }
}
impl ListSkillsOutput {
    /// Creates a new builder-style object to manufacture [`ListSkillsOutput`](crate::output::ListSkillsOutput)
    pub fn builder() -> crate::output::list_skills_output::Builder {
        crate::output::list_skills_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListGatewaysOutput {
    /// <p>The gateways in the list.</p>
    pub gateways: std::option::Option<std::vec::Vec<crate::model::GatewaySummary>>,
    /// <p>The token used to paginate though multiple pages of gateway summaries.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListGatewaysOutput {
    /// <p>The gateways in the list.</p>
    pub fn gateways(&self) -> std::option::Option<&[crate::model::GatewaySummary]> {
        self.gateways.as_deref()
    }
    /// <p>The token used to paginate though multiple pages of gateway summaries.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListGatewaysOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListGatewaysOutput");
        formatter.field("gateways", &self.gateways);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListGatewaysOutput`](crate::output::ListGatewaysOutput)
pub mod list_gateways_output {
    /// A builder for [`ListGatewaysOutput`](crate::output::ListGatewaysOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) gateways: std::option::Option<std::vec::Vec<crate::model::GatewaySummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `gateways`.
        ///
        /// To override the contents of this collection use [`set_gateways`](Self::set_gateways).
        ///
        /// <p>The gateways in the list.</p>
        pub fn gateways(mut self, input: impl Into<crate::model::GatewaySummary>) -> Self {
            let mut v = self.gateways.unwrap_or_default();
            v.push(input.into());
            self.gateways = Some(v);
            self
        }
        /// <p>The gateways in the list.</p>
        pub fn set_gateways(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::GatewaySummary>>,
        ) -> Self {
            self.gateways = input;
            self
        }
        /// <p>The token used to paginate though multiple pages of gateway summaries.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token used to paginate though multiple pages of gateway summaries.</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 [`ListGatewaysOutput`](crate::output::ListGatewaysOutput)
        pub fn build(self) -> crate::output::ListGatewaysOutput {
            crate::output::ListGatewaysOutput {
                gateways: self.gateways,
                next_token: self.next_token,
            }
        }
    }
}
impl ListGatewaysOutput {
    /// Creates a new builder-style object to manufacture [`ListGatewaysOutput`](crate::output::ListGatewaysOutput)
    pub fn builder() -> crate::output::list_gateways_output::Builder {
        crate::output::list_gateways_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListGatewayGroupsOutput {
    /// <p>The gateway groups in the list.</p>
    pub gateway_groups: std::option::Option<std::vec::Vec<crate::model::GatewayGroupSummary>>,
    /// <p>The token used to paginate though multiple pages of gateway group summaries.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListGatewayGroupsOutput {
    /// <p>The gateway groups in the list.</p>
    pub fn gateway_groups(&self) -> std::option::Option<&[crate::model::GatewayGroupSummary]> {
        self.gateway_groups.as_deref()
    }
    /// <p>The token used to paginate though multiple pages of gateway group summaries.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListGatewayGroupsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListGatewayGroupsOutput");
        formatter.field("gateway_groups", &self.gateway_groups);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListGatewayGroupsOutput`](crate::output::ListGatewayGroupsOutput)
pub mod list_gateway_groups_output {
    /// A builder for [`ListGatewayGroupsOutput`](crate::output::ListGatewayGroupsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) gateway_groups:
            std::option::Option<std::vec::Vec<crate::model::GatewayGroupSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `gateway_groups`.
        ///
        /// To override the contents of this collection use [`set_gateway_groups`](Self::set_gateway_groups).
        ///
        /// <p>The gateway groups in the list.</p>
        pub fn gateway_groups(
            mut self,
            input: impl Into<crate::model::GatewayGroupSummary>,
        ) -> Self {
            let mut v = self.gateway_groups.unwrap_or_default();
            v.push(input.into());
            self.gateway_groups = Some(v);
            self
        }
        /// <p>The gateway groups in the list.</p>
        pub fn set_gateway_groups(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::GatewayGroupSummary>>,
        ) -> Self {
            self.gateway_groups = input;
            self
        }
        /// <p>The token used to paginate though multiple pages of gateway group summaries.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token used to paginate though multiple pages of gateway group summaries.</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 [`ListGatewayGroupsOutput`](crate::output::ListGatewayGroupsOutput)
        pub fn build(self) -> crate::output::ListGatewayGroupsOutput {
            crate::output::ListGatewayGroupsOutput {
                gateway_groups: self.gateway_groups,
                next_token: self.next_token,
            }
        }
    }
}
impl ListGatewayGroupsOutput {
    /// Creates a new builder-style object to manufacture [`ListGatewayGroupsOutput`](crate::output::ListGatewayGroupsOutput)
    pub fn builder() -> crate::output::list_gateway_groups_output::Builder {
        crate::output::list_gateway_groups_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDeviceEventsOutput {
    /// <p>The device events requested for the device ARN.</p>
    pub device_events: std::option::Option<std::vec::Vec<crate::model::DeviceEvent>>,
    /// <p>The token returned to indicate that there is more data available.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDeviceEventsOutput {
    /// <p>The device events requested for the device ARN.</p>
    pub fn device_events(&self) -> std::option::Option<&[crate::model::DeviceEvent]> {
        self.device_events.as_deref()
    }
    /// <p>The token returned to indicate that there is more data available.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDeviceEventsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDeviceEventsOutput");
        formatter.field("device_events", &self.device_events);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDeviceEventsOutput`](crate::output::ListDeviceEventsOutput)
pub mod list_device_events_output {
    /// A builder for [`ListDeviceEventsOutput`](crate::output::ListDeviceEventsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) device_events: std::option::Option<std::vec::Vec<crate::model::DeviceEvent>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `device_events`.
        ///
        /// To override the contents of this collection use [`set_device_events`](Self::set_device_events).
        ///
        /// <p>The device events requested for the device ARN.</p>
        pub fn device_events(mut self, input: impl Into<crate::model::DeviceEvent>) -> Self {
            let mut v = self.device_events.unwrap_or_default();
            v.push(input.into());
            self.device_events = Some(v);
            self
        }
        /// <p>The device events requested for the device ARN.</p>
        pub fn set_device_events(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DeviceEvent>>,
        ) -> Self {
            self.device_events = input;
            self
        }
        /// <p>The token returned to indicate that there is more data available.</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 to indicate that there is more data available.</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 [`ListDeviceEventsOutput`](crate::output::ListDeviceEventsOutput)
        pub fn build(self) -> crate::output::ListDeviceEventsOutput {
            crate::output::ListDeviceEventsOutput {
                device_events: self.device_events,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDeviceEventsOutput {
    /// Creates a new builder-style object to manufacture [`ListDeviceEventsOutput`](crate::output::ListDeviceEventsOutput)
    pub fn builder() -> crate::output::list_device_events_output::Builder {
        crate::output::list_device_events_output::Builder::default()
    }
}

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListBusinessReportSchedulesOutput {
    /// <p>The schedule of the reports.</p>
    pub business_report_schedules:
        std::option::Option<std::vec::Vec<crate::model::BusinessReportSchedule>>,
    /// <p>The token used to list the remaining schedules from the previous API call.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListBusinessReportSchedulesOutput {
    /// <p>The schedule of the reports.</p>
    pub fn business_report_schedules(
        &self,
    ) -> std::option::Option<&[crate::model::BusinessReportSchedule]> {
        self.business_report_schedules.as_deref()
    }
    /// <p>The token used to list the remaining schedules from the previous API call.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListBusinessReportSchedulesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListBusinessReportSchedulesOutput");
        formatter.field("business_report_schedules", &self.business_report_schedules);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListBusinessReportSchedulesOutput`](crate::output::ListBusinessReportSchedulesOutput)
pub mod list_business_report_schedules_output {
    /// A builder for [`ListBusinessReportSchedulesOutput`](crate::output::ListBusinessReportSchedulesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) business_report_schedules:
            std::option::Option<std::vec::Vec<crate::model::BusinessReportSchedule>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `business_report_schedules`.
        ///
        /// To override the contents of this collection use [`set_business_report_schedules`](Self::set_business_report_schedules).
        ///
        /// <p>The schedule of the reports.</p>
        pub fn business_report_schedules(
            mut self,
            input: impl Into<crate::model::BusinessReportSchedule>,
        ) -> Self {
            let mut v = self.business_report_schedules.unwrap_or_default();
            v.push(input.into());
            self.business_report_schedules = Some(v);
            self
        }
        /// <p>The schedule of the reports.</p>
        pub fn set_business_report_schedules(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::BusinessReportSchedule>>,
        ) -> Self {
            self.business_report_schedules = input;
            self
        }
        /// <p>The token used to list the remaining schedules from the previous API call.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The token used to list the remaining schedules from the previous API call.</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 [`ListBusinessReportSchedulesOutput`](crate::output::ListBusinessReportSchedulesOutput)
        pub fn build(self) -> crate::output::ListBusinessReportSchedulesOutput {
            crate::output::ListBusinessReportSchedulesOutput {
                business_report_schedules: self.business_report_schedules,
                next_token: self.next_token,
            }
        }
    }
}
impl ListBusinessReportSchedulesOutput {
    /// Creates a new builder-style object to manufacture [`ListBusinessReportSchedulesOutput`](crate::output::ListBusinessReportSchedulesOutput)
    pub fn builder() -> crate::output::list_business_report_schedules_output::Builder {
        crate::output::list_business_report_schedules_output::Builder::default()
    }
}

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetInvitationConfigurationOutput {
    /// <p>The name of the organization sending the enrollment invite to a user.</p>
    pub organization_name: std::option::Option<std::string::String>,
    /// <p>The email ID of the organization or individual contact that the enrolled user can use.
    /// </p>
    pub contact_email: std::option::Option<std::string::String>,
    /// <p>The list of private skill IDs that you want to recommend to the user to enable in the
    /// invitation.</p>
    pub private_skill_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl GetInvitationConfigurationOutput {
    /// <p>The name of the organization sending the enrollment invite to a user.</p>
    pub fn organization_name(&self) -> std::option::Option<&str> {
        self.organization_name.as_deref()
    }
    /// <p>The email ID of the organization or individual contact that the enrolled user can use.
    /// </p>
    pub fn contact_email(&self) -> std::option::Option<&str> {
        self.contact_email.as_deref()
    }
    /// <p>The list of private skill IDs that you want to recommend to the user to enable in the
    /// invitation.</p>
    pub fn private_skill_ids(&self) -> std::option::Option<&[std::string::String]> {
        self.private_skill_ids.as_deref()
    }
}
impl std::fmt::Debug for GetInvitationConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetInvitationConfigurationOutput");
        formatter.field("organization_name", &self.organization_name);
        formatter.field("contact_email", &self.contact_email);
        formatter.field("private_skill_ids", &self.private_skill_ids);
        formatter.finish()
    }
}
/// See [`GetInvitationConfigurationOutput`](crate::output::GetInvitationConfigurationOutput)
pub mod get_invitation_configuration_output {
    /// A builder for [`GetInvitationConfigurationOutput`](crate::output::GetInvitationConfigurationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_name: std::option::Option<std::string::String>,
        pub(crate) contact_email: std::option::Option<std::string::String>,
        pub(crate) private_skill_ids: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        /// <p>The name of the organization sending the enrollment invite to a user.</p>
        pub fn organization_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.organization_name = Some(input.into());
            self
        }
        /// <p>The name of the organization sending the enrollment invite to a user.</p>
        pub fn set_organization_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.organization_name = input;
            self
        }
        /// <p>The email ID of the organization or individual contact that the enrolled user can use.
        /// </p>
        pub fn contact_email(mut self, input: impl Into<std::string::String>) -> Self {
            self.contact_email = Some(input.into());
            self
        }
        /// <p>The email ID of the organization or individual contact that the enrolled user can use.
        /// </p>
        pub fn set_contact_email(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.contact_email = input;
            self
        }
        /// Appends an item to `private_skill_ids`.
        ///
        /// To override the contents of this collection use [`set_private_skill_ids`](Self::set_private_skill_ids).
        ///
        /// <p>The list of private skill IDs that you want to recommend to the user to enable in the
        /// invitation.</p>
        pub fn private_skill_ids(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.private_skill_ids.unwrap_or_default();
            v.push(input.into());
            self.private_skill_ids = Some(v);
            self
        }
        /// <p>The list of private skill IDs that you want to recommend to the user to enable in the
        /// invitation.</p>
        pub fn set_private_skill_ids(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.private_skill_ids = input;
            self
        }
        /// Consumes the builder and constructs a [`GetInvitationConfigurationOutput`](crate::output::GetInvitationConfigurationOutput)
        pub fn build(self) -> crate::output::GetInvitationConfigurationOutput {
            crate::output::GetInvitationConfigurationOutput {
                organization_name: self.organization_name,
                contact_email: self.contact_email,
                private_skill_ids: self.private_skill_ids,
            }
        }
    }
}
impl GetInvitationConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`GetInvitationConfigurationOutput`](crate::output::GetInvitationConfigurationOutput)
    pub fn builder() -> crate::output::get_invitation_configuration_output::Builder {
        crate::output::get_invitation_configuration_output::Builder::default()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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