aws-sdk-opsworks 0.19.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 UpdateVolumeOutput {}
impl std::fmt::Debug for UpdateVolumeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateVolumeOutput");
        formatter.finish()
    }
}
/// See [`UpdateVolumeOutput`](crate::output::UpdateVolumeOutput).
pub mod update_volume_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateUserProfileOutput {}
impl std::fmt::Debug for UpdateUserProfileOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateUserProfileOutput");
        formatter.finish()
    }
}
/// See [`UpdateUserProfileOutput`](crate::output::UpdateUserProfileOutput).
pub mod update_user_profile_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateStackOutput {}
impl std::fmt::Debug for UpdateStackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateStackOutput");
        formatter.finish()
    }
}
/// See [`UpdateStackOutput`](crate::output::UpdateStackOutput).
pub mod update_stack_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateRdsDbInstanceOutput {}
impl std::fmt::Debug for UpdateRdsDbInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateRdsDbInstanceOutput");
        formatter.finish()
    }
}
/// See [`UpdateRdsDbInstanceOutput`](crate::output::UpdateRdsDbInstanceOutput).
pub mod update_rds_db_instance_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateMyUserProfileOutput {}
impl std::fmt::Debug for UpdateMyUserProfileOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateMyUserProfileOutput");
        formatter.finish()
    }
}
/// See [`UpdateMyUserProfileOutput`](crate::output::UpdateMyUserProfileOutput).
pub mod update_my_user_profile_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateLayerOutput {}
impl std::fmt::Debug for UpdateLayerOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateLayerOutput");
        formatter.finish()
    }
}
/// See [`UpdateLayerOutput`](crate::output::UpdateLayerOutput).
pub mod update_layer_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateInstanceOutput {}
impl std::fmt::Debug for UpdateInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateInstanceOutput");
        formatter.finish()
    }
}
/// See [`UpdateInstanceOutput`](crate::output::UpdateInstanceOutput).
pub mod update_instance_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateElasticIpOutput {}
impl std::fmt::Debug for UpdateElasticIpOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateElasticIpOutput");
        formatter.finish()
    }
}
/// See [`UpdateElasticIpOutput`](crate::output::UpdateElasticIpOutput).
pub mod update_elastic_ip_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateAppOutput {}
impl std::fmt::Debug for UpdateAppOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateAppOutput");
        formatter.finish()
    }
}
/// See [`UpdateAppOutput`](crate::output::UpdateAppOutput).
pub mod update_app_output {

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UnassignInstanceOutput {}
impl std::fmt::Debug for UnassignInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UnassignInstanceOutput");
        formatter.finish()
    }
}
/// See [`UnassignInstanceOutput`](crate::output::UnassignInstanceOutput).
pub mod unassign_instance_output {

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StopInstanceOutput {}
impl std::fmt::Debug for StopInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StopInstanceOutput");
        formatter.finish()
    }
}
/// See [`StopInstanceOutput`](crate::output::StopInstanceOutput).
pub mod stop_instance_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartStackOutput {}
impl std::fmt::Debug for StartStackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartStackOutput");
        formatter.finish()
    }
}
/// See [`StartStackOutput`](crate::output::StartStackOutput).
pub mod start_stack_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartInstanceOutput {}
impl std::fmt::Debug for StartInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartInstanceOutput");
        formatter.finish()
    }
}
/// See [`StartInstanceOutput`](crate::output::StartInstanceOutput).
pub mod start_instance_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SetTimeBasedAutoScalingOutput {}
impl std::fmt::Debug for SetTimeBasedAutoScalingOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SetTimeBasedAutoScalingOutput");
        formatter.finish()
    }
}
/// See [`SetTimeBasedAutoScalingOutput`](crate::output::SetTimeBasedAutoScalingOutput).
pub mod set_time_based_auto_scaling_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SetPermissionOutput {}
impl std::fmt::Debug for SetPermissionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SetPermissionOutput");
        formatter.finish()
    }
}
/// See [`SetPermissionOutput`](crate::output::SetPermissionOutput).
pub mod set_permission_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SetLoadBasedAutoScalingOutput {}
impl std::fmt::Debug for SetLoadBasedAutoScalingOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SetLoadBasedAutoScalingOutput");
        formatter.finish()
    }
}
/// See [`SetLoadBasedAutoScalingOutput`](crate::output::SetLoadBasedAutoScalingOutput).
pub mod set_load_based_auto_scaling_output {

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

/// <p>Contains the response to a <code>RegisterVolume</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterVolumeOutput {
    /// <p>The volume ID.</p>
    #[doc(hidden)]
    pub volume_id: std::option::Option<std::string::String>,
}
impl RegisterVolumeOutput {
    /// <p>The volume ID.</p>
    pub fn volume_id(&self) -> std::option::Option<&str> {
        self.volume_id.as_deref()
    }
}
impl std::fmt::Debug for RegisterVolumeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterVolumeOutput");
        formatter.field("volume_id", &self.volume_id);
        formatter.finish()
    }
}
/// See [`RegisterVolumeOutput`](crate::output::RegisterVolumeOutput).
pub mod register_volume_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterRdsDbInstanceOutput {}
impl std::fmt::Debug for RegisterRdsDbInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterRdsDbInstanceOutput");
        formatter.finish()
    }
}
/// See [`RegisterRdsDbInstanceOutput`](crate::output::RegisterRdsDbInstanceOutput).
pub mod register_rds_db_instance_output {

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

/// <p>Contains the response to a <code>RegisterInstanceResult</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterInstanceOutput {
    /// <p>The registered instance's AWS OpsWorks Stacks ID.</p>
    #[doc(hidden)]
    pub instance_id: std::option::Option<std::string::String>,
}
impl RegisterInstanceOutput {
    /// <p>The registered instance's AWS OpsWorks Stacks ID.</p>
    pub fn instance_id(&self) -> std::option::Option<&str> {
        self.instance_id.as_deref()
    }
}
impl std::fmt::Debug for RegisterInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterInstanceOutput");
        formatter.field("instance_id", &self.instance_id);
        formatter.finish()
    }
}
/// See [`RegisterInstanceOutput`](crate::output::RegisterInstanceOutput).
pub mod register_instance_output {

    /// A builder for [`RegisterInstanceOutput`](crate::output::RegisterInstanceOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) instance_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The registered instance's AWS OpsWorks Stacks ID.</p>
        pub fn instance_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.instance_id = Some(input.into());
            self
        }
        /// <p>The registered instance's AWS OpsWorks Stacks ID.</p>
        pub fn set_instance_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.instance_id = input;
            self
        }
        /// Consumes the builder and constructs a [`RegisterInstanceOutput`](crate::output::RegisterInstanceOutput).
        pub fn build(self) -> crate::output::RegisterInstanceOutput {
            crate::output::RegisterInstanceOutput {
                instance_id: self.instance_id,
            }
        }
    }
}
impl RegisterInstanceOutput {
    /// Creates a new builder-style object to manufacture [`RegisterInstanceOutput`](crate::output::RegisterInstanceOutput).
    pub fn builder() -> crate::output::register_instance_output::Builder {
        crate::output::register_instance_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>RegisterElasticIp</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterElasticIpOutput {
    /// <p>The Elastic IP address.</p>
    #[doc(hidden)]
    pub elastic_ip: std::option::Option<std::string::String>,
}
impl RegisterElasticIpOutput {
    /// <p>The Elastic IP address.</p>
    pub fn elastic_ip(&self) -> std::option::Option<&str> {
        self.elastic_ip.as_deref()
    }
}
impl std::fmt::Debug for RegisterElasticIpOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterElasticIpOutput");
        formatter.field("elastic_ip", &self.elastic_ip);
        formatter.finish()
    }
}
/// See [`RegisterElasticIpOutput`](crate::output::RegisterElasticIpOutput).
pub mod register_elastic_ip_output {

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

/// <p>Contains the response to a <code>RegisterEcsCluster</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterEcsClusterOutput {
    /// <p>The cluster's ARN.</p>
    #[doc(hidden)]
    pub ecs_cluster_arn: std::option::Option<std::string::String>,
}
impl RegisterEcsClusterOutput {
    /// <p>The cluster's ARN.</p>
    pub fn ecs_cluster_arn(&self) -> std::option::Option<&str> {
        self.ecs_cluster_arn.as_deref()
    }
}
impl std::fmt::Debug for RegisterEcsClusterOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RegisterEcsClusterOutput");
        formatter.field("ecs_cluster_arn", &self.ecs_cluster_arn);
        formatter.finish()
    }
}
/// See [`RegisterEcsClusterOutput`](crate::output::RegisterEcsClusterOutput).
pub mod register_ecs_cluster_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RebootInstanceOutput {}
impl std::fmt::Debug for RebootInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("RebootInstanceOutput");
        formatter.finish()
    }
}
/// See [`RebootInstanceOutput`](crate::output::RebootInstanceOutput).
pub mod reboot_instance_output {

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

/// <p>Contains the response to a <code>ListTags</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsOutput {
    /// <p>A set of key-value pairs that contain tag keys and tag values that are attached to a stack or layer.</p>
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
    /// <p>If a paginated request does not return all of the remaining results, this parameter is set to a token that you can assign to the request object's <code>NextToken</code> parameter to get the next set of results. If the previous paginated request returned all of the remaining results, this parameter is set to <code>null</code>. </p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListTagsOutput {
    /// <p>A set of key-value pairs that contain tag keys and tag values that are attached to a stack or layer.</p>
    pub fn tags(
        &self,
    ) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
    {
        self.tags.as_ref()
    }
    /// <p>If a paginated request does not return all of the remaining results, this parameter is set to a token that you can assign to the request object's <code>NextToken</code> parameter to get the next set of results. If the previous paginated request returned all of the remaining results, this parameter is set to <code>null</code>. </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).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>A set of key-value pairs that contain tag keys and tag values that are attached to a stack or layer.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.tags.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.tags = Some(hash_map);
            self
        }
        /// <p>A set of key-value pairs that contain tag keys and tag values that are attached to a stack or layer.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.tags = input;
            self
        }
        /// <p>If a paginated request does not return all of the remaining results, this parameter is set to a token that you can assign to the request object's <code>NextToken</code> parameter to get the next set of results. If the previous paginated request returned all of the remaining results, this parameter is set to <code>null</code>. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>If a paginated request does not return all of the remaining results, this parameter is set to a token that you can assign to the request object's <code>NextToken</code> parameter to get the next set of results. If the previous paginated request returned all of the remaining results, this parameter is set to <code>null</code>. </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()
    }
}

/// <p>Contains the response to a <code>GrantAccess</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GrantAccessOutput {
    /// <p>A <code>TemporaryCredential</code> object that contains the data needed to log in to the instance by RDP clients, such as the Microsoft Remote Desktop Connection.</p>
    #[doc(hidden)]
    pub temporary_credential: std::option::Option<crate::model::TemporaryCredential>,
}
impl GrantAccessOutput {
    /// <p>A <code>TemporaryCredential</code> object that contains the data needed to log in to the instance by RDP clients, such as the Microsoft Remote Desktop Connection.</p>
    pub fn temporary_credential(&self) -> std::option::Option<&crate::model::TemporaryCredential> {
        self.temporary_credential.as_ref()
    }
}
impl std::fmt::Debug for GrantAccessOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GrantAccessOutput");
        formatter.field("temporary_credential", &self.temporary_credential);
        formatter.finish()
    }
}
/// See [`GrantAccessOutput`](crate::output::GrantAccessOutput).
pub mod grant_access_output {

    /// A builder for [`GrantAccessOutput`](crate::output::GrantAccessOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) temporary_credential: std::option::Option<crate::model::TemporaryCredential>,
    }
    impl Builder {
        /// <p>A <code>TemporaryCredential</code> object that contains the data needed to log in to the instance by RDP clients, such as the Microsoft Remote Desktop Connection.</p>
        pub fn temporary_credential(mut self, input: crate::model::TemporaryCredential) -> Self {
            self.temporary_credential = Some(input);
            self
        }
        /// <p>A <code>TemporaryCredential</code> object that contains the data needed to log in to the instance by RDP clients, such as the Microsoft Remote Desktop Connection.</p>
        pub fn set_temporary_credential(
            mut self,
            input: std::option::Option<crate::model::TemporaryCredential>,
        ) -> Self {
            self.temporary_credential = input;
            self
        }
        /// Consumes the builder and constructs a [`GrantAccessOutput`](crate::output::GrantAccessOutput).
        pub fn build(self) -> crate::output::GrantAccessOutput {
            crate::output::GrantAccessOutput {
                temporary_credential: self.temporary_credential,
            }
        }
    }
}
impl GrantAccessOutput {
    /// Creates a new builder-style object to manufacture [`GrantAccessOutput`](crate::output::GrantAccessOutput).
    pub fn builder() -> crate::output::grant_access_output::Builder {
        crate::output::grant_access_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>GetHostnameSuggestion</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetHostnameSuggestionOutput {
    /// <p>The layer ID.</p>
    #[doc(hidden)]
    pub layer_id: std::option::Option<std::string::String>,
    /// <p>The generated host name.</p>
    #[doc(hidden)]
    pub hostname: std::option::Option<std::string::String>,
}
impl GetHostnameSuggestionOutput {
    /// <p>The layer ID.</p>
    pub fn layer_id(&self) -> std::option::Option<&str> {
        self.layer_id.as_deref()
    }
    /// <p>The generated host name.</p>
    pub fn hostname(&self) -> std::option::Option<&str> {
        self.hostname.as_deref()
    }
}
impl std::fmt::Debug for GetHostnameSuggestionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetHostnameSuggestionOutput");
        formatter.field("layer_id", &self.layer_id);
        formatter.field("hostname", &self.hostname);
        formatter.finish()
    }
}
/// See [`GetHostnameSuggestionOutput`](crate::output::GetHostnameSuggestionOutput).
pub mod get_hostname_suggestion_output {

    /// A builder for [`GetHostnameSuggestionOutput`](crate::output::GetHostnameSuggestionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) layer_id: std::option::Option<std::string::String>,
        pub(crate) hostname: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The layer ID.</p>
        pub fn layer_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.layer_id = Some(input.into());
            self
        }
        /// <p>The layer ID.</p>
        pub fn set_layer_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.layer_id = input;
            self
        }
        /// <p>The generated host name.</p>
        pub fn hostname(mut self, input: impl Into<std::string::String>) -> Self {
            self.hostname = Some(input.into());
            self
        }
        /// <p>The generated host name.</p>
        pub fn set_hostname(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.hostname = input;
            self
        }
        /// Consumes the builder and constructs a [`GetHostnameSuggestionOutput`](crate::output::GetHostnameSuggestionOutput).
        pub fn build(self) -> crate::output::GetHostnameSuggestionOutput {
            crate::output::GetHostnameSuggestionOutput {
                layer_id: self.layer_id,
                hostname: self.hostname,
            }
        }
    }
}
impl GetHostnameSuggestionOutput {
    /// Creates a new builder-style object to manufacture [`GetHostnameSuggestionOutput`](crate::output::GetHostnameSuggestionOutput).
    pub fn builder() -> crate::output::get_hostname_suggestion_output::Builder {
        crate::output::get_hostname_suggestion_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateElasticIpOutput {}
impl std::fmt::Debug for DisassociateElasticIpOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DisassociateElasticIpOutput");
        formatter.finish()
    }
}
/// See [`DisassociateElasticIpOutput`](crate::output::DisassociateElasticIpOutput).
pub mod disassociate_elastic_ip_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DetachElasticLoadBalancerOutput {}
impl std::fmt::Debug for DetachElasticLoadBalancerOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DetachElasticLoadBalancerOutput");
        formatter.finish()
    }
}
/// See [`DetachElasticLoadBalancerOutput`](crate::output::DetachElasticLoadBalancerOutput).
pub mod detach_elastic_load_balancer_output {

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

/// <p>Contains the response to a <code>DescribeVolumes</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeVolumesOutput {
    /// <p>An array of volume IDs.</p>
    #[doc(hidden)]
    pub volumes: std::option::Option<std::vec::Vec<crate::model::Volume>>,
}
impl DescribeVolumesOutput {
    /// <p>An array of volume IDs.</p>
    pub fn volumes(&self) -> std::option::Option<&[crate::model::Volume]> {
        self.volumes.as_deref()
    }
}
impl std::fmt::Debug for DescribeVolumesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeVolumesOutput");
        formatter.field("volumes", &self.volumes);
        formatter.finish()
    }
}
/// See [`DescribeVolumesOutput`](crate::output::DescribeVolumesOutput).
pub mod describe_volumes_output {

    /// A builder for [`DescribeVolumesOutput`](crate::output::DescribeVolumesOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) volumes: std::option::Option<std::vec::Vec<crate::model::Volume>>,
    }
    impl Builder {
        /// Appends an item to `volumes`.
        ///
        /// To override the contents of this collection use [`set_volumes`](Self::set_volumes).
        ///
        /// <p>An array of volume IDs.</p>
        pub fn volumes(mut self, input: crate::model::Volume) -> Self {
            let mut v = self.volumes.unwrap_or_default();
            v.push(input);
            self.volumes = Some(v);
            self
        }
        /// <p>An array of volume IDs.</p>
        pub fn set_volumes(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Volume>>,
        ) -> Self {
            self.volumes = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeVolumesOutput`](crate::output::DescribeVolumesOutput).
        pub fn build(self) -> crate::output::DescribeVolumesOutput {
            crate::output::DescribeVolumesOutput {
                volumes: self.volumes,
            }
        }
    }
}
impl DescribeVolumesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeVolumesOutput`](crate::output::DescribeVolumesOutput).
    pub fn builder() -> crate::output::describe_volumes_output::Builder {
        crate::output::describe_volumes_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeUserProfiles</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeUserProfilesOutput {
    /// <p>A <code>Users</code> object that describes the specified users.</p>
    #[doc(hidden)]
    pub user_profiles: std::option::Option<std::vec::Vec<crate::model::UserProfile>>,
}
impl DescribeUserProfilesOutput {
    /// <p>A <code>Users</code> object that describes the specified users.</p>
    pub fn user_profiles(&self) -> std::option::Option<&[crate::model::UserProfile]> {
        self.user_profiles.as_deref()
    }
}
impl std::fmt::Debug for DescribeUserProfilesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeUserProfilesOutput");
        formatter.field("user_profiles", &self.user_profiles);
        formatter.finish()
    }
}
/// See [`DescribeUserProfilesOutput`](crate::output::DescribeUserProfilesOutput).
pub mod describe_user_profiles_output {

    /// A builder for [`DescribeUserProfilesOutput`](crate::output::DescribeUserProfilesOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) user_profiles: std::option::Option<std::vec::Vec<crate::model::UserProfile>>,
    }
    impl Builder {
        /// Appends an item to `user_profiles`.
        ///
        /// To override the contents of this collection use [`set_user_profiles`](Self::set_user_profiles).
        ///
        /// <p>A <code>Users</code> object that describes the specified users.</p>
        pub fn user_profiles(mut self, input: crate::model::UserProfile) -> Self {
            let mut v = self.user_profiles.unwrap_or_default();
            v.push(input);
            self.user_profiles = Some(v);
            self
        }
        /// <p>A <code>Users</code> object that describes the specified users.</p>
        pub fn set_user_profiles(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::UserProfile>>,
        ) -> Self {
            self.user_profiles = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeUserProfilesOutput`](crate::output::DescribeUserProfilesOutput).
        pub fn build(self) -> crate::output::DescribeUserProfilesOutput {
            crate::output::DescribeUserProfilesOutput {
                user_profiles: self.user_profiles,
            }
        }
    }
}
impl DescribeUserProfilesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeUserProfilesOutput`](crate::output::DescribeUserProfilesOutput).
    pub fn builder() -> crate::output::describe_user_profiles_output::Builder {
        crate::output::describe_user_profiles_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeTimeBasedAutoScaling</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeTimeBasedAutoScalingOutput {
    /// <p>An array of <code>TimeBasedAutoScalingConfiguration</code> objects that describe the configuration for the specified instances.</p>
    #[doc(hidden)]
    pub time_based_auto_scaling_configurations:
        std::option::Option<std::vec::Vec<crate::model::TimeBasedAutoScalingConfiguration>>,
}
impl DescribeTimeBasedAutoScalingOutput {
    /// <p>An array of <code>TimeBasedAutoScalingConfiguration</code> objects that describe the configuration for the specified instances.</p>
    pub fn time_based_auto_scaling_configurations(
        &self,
    ) -> std::option::Option<&[crate::model::TimeBasedAutoScalingConfiguration]> {
        self.time_based_auto_scaling_configurations.as_deref()
    }
}
impl std::fmt::Debug for DescribeTimeBasedAutoScalingOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeTimeBasedAutoScalingOutput");
        formatter.field(
            "time_based_auto_scaling_configurations",
            &self.time_based_auto_scaling_configurations,
        );
        formatter.finish()
    }
}
/// See [`DescribeTimeBasedAutoScalingOutput`](crate::output::DescribeTimeBasedAutoScalingOutput).
pub mod describe_time_based_auto_scaling_output {

    /// A builder for [`DescribeTimeBasedAutoScalingOutput`](crate::output::DescribeTimeBasedAutoScalingOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) time_based_auto_scaling_configurations:
            std::option::Option<std::vec::Vec<crate::model::TimeBasedAutoScalingConfiguration>>,
    }
    impl Builder {
        /// Appends an item to `time_based_auto_scaling_configurations`.
        ///
        /// To override the contents of this collection use [`set_time_based_auto_scaling_configurations`](Self::set_time_based_auto_scaling_configurations).
        ///
        /// <p>An array of <code>TimeBasedAutoScalingConfiguration</code> objects that describe the configuration for the specified instances.</p>
        pub fn time_based_auto_scaling_configurations(
            mut self,
            input: crate::model::TimeBasedAutoScalingConfiguration,
        ) -> Self {
            let mut v = self
                .time_based_auto_scaling_configurations
                .unwrap_or_default();
            v.push(input);
            self.time_based_auto_scaling_configurations = Some(v);
            self
        }
        /// <p>An array of <code>TimeBasedAutoScalingConfiguration</code> objects that describe the configuration for the specified instances.</p>
        pub fn set_time_based_auto_scaling_configurations(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::TimeBasedAutoScalingConfiguration>,
            >,
        ) -> Self {
            self.time_based_auto_scaling_configurations = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeTimeBasedAutoScalingOutput`](crate::output::DescribeTimeBasedAutoScalingOutput).
        pub fn build(self) -> crate::output::DescribeTimeBasedAutoScalingOutput {
            crate::output::DescribeTimeBasedAutoScalingOutput {
                time_based_auto_scaling_configurations: self.time_based_auto_scaling_configurations,
            }
        }
    }
}
impl DescribeTimeBasedAutoScalingOutput {
    /// Creates a new builder-style object to manufacture [`DescribeTimeBasedAutoScalingOutput`](crate::output::DescribeTimeBasedAutoScalingOutput).
    pub fn builder() -> crate::output::describe_time_based_auto_scaling_output::Builder {
        crate::output::describe_time_based_auto_scaling_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeStackSummary</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeStackSummaryOutput {
    /// <p>A <code>StackSummary</code> object that contains the results.</p>
    #[doc(hidden)]
    pub stack_summary: std::option::Option<crate::model::StackSummary>,
}
impl DescribeStackSummaryOutput {
    /// <p>A <code>StackSummary</code> object that contains the results.</p>
    pub fn stack_summary(&self) -> std::option::Option<&crate::model::StackSummary> {
        self.stack_summary.as_ref()
    }
}
impl std::fmt::Debug for DescribeStackSummaryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeStackSummaryOutput");
        formatter.field("stack_summary", &self.stack_summary);
        formatter.finish()
    }
}
/// See [`DescribeStackSummaryOutput`](crate::output::DescribeStackSummaryOutput).
pub mod describe_stack_summary_output {

    /// A builder for [`DescribeStackSummaryOutput`](crate::output::DescribeStackSummaryOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) stack_summary: std::option::Option<crate::model::StackSummary>,
    }
    impl Builder {
        /// <p>A <code>StackSummary</code> object that contains the results.</p>
        pub fn stack_summary(mut self, input: crate::model::StackSummary) -> Self {
            self.stack_summary = Some(input);
            self
        }
        /// <p>A <code>StackSummary</code> object that contains the results.</p>
        pub fn set_stack_summary(
            mut self,
            input: std::option::Option<crate::model::StackSummary>,
        ) -> Self {
            self.stack_summary = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeStackSummaryOutput`](crate::output::DescribeStackSummaryOutput).
        pub fn build(self) -> crate::output::DescribeStackSummaryOutput {
            crate::output::DescribeStackSummaryOutput {
                stack_summary: self.stack_summary,
            }
        }
    }
}
impl DescribeStackSummaryOutput {
    /// Creates a new builder-style object to manufacture [`DescribeStackSummaryOutput`](crate::output::DescribeStackSummaryOutput).
    pub fn builder() -> crate::output::describe_stack_summary_output::Builder {
        crate::output::describe_stack_summary_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeStacks</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeStacksOutput {
    /// <p>An array of <code>Stack</code> objects that describe the stacks.</p>
    #[doc(hidden)]
    pub stacks: std::option::Option<std::vec::Vec<crate::model::Stack>>,
}
impl DescribeStacksOutput {
    /// <p>An array of <code>Stack</code> objects that describe the stacks.</p>
    pub fn stacks(&self) -> std::option::Option<&[crate::model::Stack]> {
        self.stacks.as_deref()
    }
}
impl std::fmt::Debug for DescribeStacksOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeStacksOutput");
        formatter.field("stacks", &self.stacks);
        formatter.finish()
    }
}
/// See [`DescribeStacksOutput`](crate::output::DescribeStacksOutput).
pub mod describe_stacks_output {

    /// A builder for [`DescribeStacksOutput`](crate::output::DescribeStacksOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) stacks: std::option::Option<std::vec::Vec<crate::model::Stack>>,
    }
    impl Builder {
        /// Appends an item to `stacks`.
        ///
        /// To override the contents of this collection use [`set_stacks`](Self::set_stacks).
        ///
        /// <p>An array of <code>Stack</code> objects that describe the stacks.</p>
        pub fn stacks(mut self, input: crate::model::Stack) -> Self {
            let mut v = self.stacks.unwrap_or_default();
            v.push(input);
            self.stacks = Some(v);
            self
        }
        /// <p>An array of <code>Stack</code> objects that describe the stacks.</p>
        pub fn set_stacks(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Stack>>,
        ) -> Self {
            self.stacks = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeStacksOutput`](crate::output::DescribeStacksOutput).
        pub fn build(self) -> crate::output::DescribeStacksOutput {
            crate::output::DescribeStacksOutput {
                stacks: self.stacks,
            }
        }
    }
}
impl DescribeStacksOutput {
    /// Creates a new builder-style object to manufacture [`DescribeStacksOutput`](crate::output::DescribeStacksOutput).
    pub fn builder() -> crate::output::describe_stacks_output::Builder {
        crate::output::describe_stacks_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeStackProvisioningParameters</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeStackProvisioningParametersOutput {
    /// <p>The AWS OpsWorks Stacks agent installer's URL.</p>
    #[doc(hidden)]
    pub agent_installer_url: std::option::Option<std::string::String>,
    /// <p>An embedded object that contains the provisioning parameters.</p>
    #[doc(hidden)]
    pub parameters:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl DescribeStackProvisioningParametersOutput {
    /// <p>The AWS OpsWorks Stacks agent installer's URL.</p>
    pub fn agent_installer_url(&self) -> std::option::Option<&str> {
        self.agent_installer_url.as_deref()
    }
    /// <p>An embedded object that contains the provisioning parameters.</p>
    pub fn parameters(
        &self,
    ) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
    {
        self.parameters.as_ref()
    }
}
impl std::fmt::Debug for DescribeStackProvisioningParametersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeStackProvisioningParametersOutput");
        formatter.field("agent_installer_url", &self.agent_installer_url);
        formatter.field("parameters", &self.parameters);
        formatter.finish()
    }
}
/// See [`DescribeStackProvisioningParametersOutput`](crate::output::DescribeStackProvisioningParametersOutput).
pub mod describe_stack_provisioning_parameters_output {

    /// A builder for [`DescribeStackProvisioningParametersOutput`](crate::output::DescribeStackProvisioningParametersOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) agent_installer_url: std::option::Option<std::string::String>,
        pub(crate) parameters: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// <p>The AWS OpsWorks Stacks agent installer's URL.</p>
        pub fn agent_installer_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.agent_installer_url = Some(input.into());
            self
        }
        /// <p>The AWS OpsWorks Stacks agent installer's URL.</p>
        pub fn set_agent_installer_url(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.agent_installer_url = input;
            self
        }
        /// Adds a key-value pair to `parameters`.
        ///
        /// To override the contents of this collection use [`set_parameters`](Self::set_parameters).
        ///
        /// <p>An embedded object that contains the provisioning parameters.</p>
        pub fn parameters(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.parameters.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.parameters = Some(hash_map);
            self
        }
        /// <p>An embedded object that contains the provisioning parameters.</p>
        pub fn set_parameters(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.parameters = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeStackProvisioningParametersOutput`](crate::output::DescribeStackProvisioningParametersOutput).
        pub fn build(self) -> crate::output::DescribeStackProvisioningParametersOutput {
            crate::output::DescribeStackProvisioningParametersOutput {
                agent_installer_url: self.agent_installer_url,
                parameters: self.parameters,
            }
        }
    }
}
impl DescribeStackProvisioningParametersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeStackProvisioningParametersOutput`](crate::output::DescribeStackProvisioningParametersOutput).
    pub fn builder() -> crate::output::describe_stack_provisioning_parameters_output::Builder {
        crate::output::describe_stack_provisioning_parameters_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeServiceErrors</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeServiceErrorsOutput {
    /// <p>An array of <code>ServiceError</code> objects that describe the specified service errors.</p>
    #[doc(hidden)]
    pub service_errors: std::option::Option<std::vec::Vec<crate::model::ServiceError>>,
}
impl DescribeServiceErrorsOutput {
    /// <p>An array of <code>ServiceError</code> objects that describe the specified service errors.</p>
    pub fn service_errors(&self) -> std::option::Option<&[crate::model::ServiceError]> {
        self.service_errors.as_deref()
    }
}
impl std::fmt::Debug for DescribeServiceErrorsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeServiceErrorsOutput");
        formatter.field("service_errors", &self.service_errors);
        formatter.finish()
    }
}
/// See [`DescribeServiceErrorsOutput`](crate::output::DescribeServiceErrorsOutput).
pub mod describe_service_errors_output {

    /// A builder for [`DescribeServiceErrorsOutput`](crate::output::DescribeServiceErrorsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_errors: std::option::Option<std::vec::Vec<crate::model::ServiceError>>,
    }
    impl Builder {
        /// Appends an item to `service_errors`.
        ///
        /// To override the contents of this collection use [`set_service_errors`](Self::set_service_errors).
        ///
        /// <p>An array of <code>ServiceError</code> objects that describe the specified service errors.</p>
        pub fn service_errors(mut self, input: crate::model::ServiceError) -> Self {
            let mut v = self.service_errors.unwrap_or_default();
            v.push(input);
            self.service_errors = Some(v);
            self
        }
        /// <p>An array of <code>ServiceError</code> objects that describe the specified service errors.</p>
        pub fn set_service_errors(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ServiceError>>,
        ) -> Self {
            self.service_errors = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeServiceErrorsOutput`](crate::output::DescribeServiceErrorsOutput).
        pub fn build(self) -> crate::output::DescribeServiceErrorsOutput {
            crate::output::DescribeServiceErrorsOutput {
                service_errors: self.service_errors,
            }
        }
    }
}
impl DescribeServiceErrorsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeServiceErrorsOutput`](crate::output::DescribeServiceErrorsOutput).
    pub fn builder() -> crate::output::describe_service_errors_output::Builder {
        crate::output::describe_service_errors_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeRdsDbInstances</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeRdsDbInstancesOutput {
    /// <p>An a array of <code>RdsDbInstance</code> objects that describe the instances.</p>
    #[doc(hidden)]
    pub rds_db_instances: std::option::Option<std::vec::Vec<crate::model::RdsDbInstance>>,
}
impl DescribeRdsDbInstancesOutput {
    /// <p>An a array of <code>RdsDbInstance</code> objects that describe the instances.</p>
    pub fn rds_db_instances(&self) -> std::option::Option<&[crate::model::RdsDbInstance]> {
        self.rds_db_instances.as_deref()
    }
}
impl std::fmt::Debug for DescribeRdsDbInstancesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeRdsDbInstancesOutput");
        formatter.field("rds_db_instances", &self.rds_db_instances);
        formatter.finish()
    }
}
/// See [`DescribeRdsDbInstancesOutput`](crate::output::DescribeRdsDbInstancesOutput).
pub mod describe_rds_db_instances_output {

    /// A builder for [`DescribeRdsDbInstancesOutput`](crate::output::DescribeRdsDbInstancesOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) rds_db_instances:
            std::option::Option<std::vec::Vec<crate::model::RdsDbInstance>>,
    }
    impl Builder {
        /// Appends an item to `rds_db_instances`.
        ///
        /// To override the contents of this collection use [`set_rds_db_instances`](Self::set_rds_db_instances).
        ///
        /// <p>An a array of <code>RdsDbInstance</code> objects that describe the instances.</p>
        pub fn rds_db_instances(mut self, input: crate::model::RdsDbInstance) -> Self {
            let mut v = self.rds_db_instances.unwrap_or_default();
            v.push(input);
            self.rds_db_instances = Some(v);
            self
        }
        /// <p>An a array of <code>RdsDbInstance</code> objects that describe the instances.</p>
        pub fn set_rds_db_instances(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RdsDbInstance>>,
        ) -> Self {
            self.rds_db_instances = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeRdsDbInstancesOutput`](crate::output::DescribeRdsDbInstancesOutput).
        pub fn build(self) -> crate::output::DescribeRdsDbInstancesOutput {
            crate::output::DescribeRdsDbInstancesOutput {
                rds_db_instances: self.rds_db_instances,
            }
        }
    }
}
impl DescribeRdsDbInstancesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeRdsDbInstancesOutput`](crate::output::DescribeRdsDbInstancesOutput).
    pub fn builder() -> crate::output::describe_rds_db_instances_output::Builder {
        crate::output::describe_rds_db_instances_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeRaidArrays</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeRaidArraysOutput {
    /// <p>A <code>RaidArrays</code> object that describes the specified RAID arrays.</p>
    #[doc(hidden)]
    pub raid_arrays: std::option::Option<std::vec::Vec<crate::model::RaidArray>>,
}
impl DescribeRaidArraysOutput {
    /// <p>A <code>RaidArrays</code> object that describes the specified RAID arrays.</p>
    pub fn raid_arrays(&self) -> std::option::Option<&[crate::model::RaidArray]> {
        self.raid_arrays.as_deref()
    }
}
impl std::fmt::Debug for DescribeRaidArraysOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeRaidArraysOutput");
        formatter.field("raid_arrays", &self.raid_arrays);
        formatter.finish()
    }
}
/// See [`DescribeRaidArraysOutput`](crate::output::DescribeRaidArraysOutput).
pub mod describe_raid_arrays_output {

    /// A builder for [`DescribeRaidArraysOutput`](crate::output::DescribeRaidArraysOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) raid_arrays: std::option::Option<std::vec::Vec<crate::model::RaidArray>>,
    }
    impl Builder {
        /// Appends an item to `raid_arrays`.
        ///
        /// To override the contents of this collection use [`set_raid_arrays`](Self::set_raid_arrays).
        ///
        /// <p>A <code>RaidArrays</code> object that describes the specified RAID arrays.</p>
        pub fn raid_arrays(mut self, input: crate::model::RaidArray) -> Self {
            let mut v = self.raid_arrays.unwrap_or_default();
            v.push(input);
            self.raid_arrays = Some(v);
            self
        }
        /// <p>A <code>RaidArrays</code> object that describes the specified RAID arrays.</p>
        pub fn set_raid_arrays(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RaidArray>>,
        ) -> Self {
            self.raid_arrays = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeRaidArraysOutput`](crate::output::DescribeRaidArraysOutput).
        pub fn build(self) -> crate::output::DescribeRaidArraysOutput {
            crate::output::DescribeRaidArraysOutput {
                raid_arrays: self.raid_arrays,
            }
        }
    }
}
impl DescribeRaidArraysOutput {
    /// Creates a new builder-style object to manufacture [`DescribeRaidArraysOutput`](crate::output::DescribeRaidArraysOutput).
    pub fn builder() -> crate::output::describe_raid_arrays_output::Builder {
        crate::output::describe_raid_arrays_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribePermissions</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribePermissionsOutput {
    /// <p>An array of <code>Permission</code> objects that describe the stack permissions.</p>
    /// <ul>
    /// <li> <p>If the request object contains only a stack ID, the array contains a <code>Permission</code> object with permissions for each of the stack IAM ARNs.</p> </li>
    /// <li> <p>If the request object contains only an IAM ARN, the array contains a <code>Permission</code> object with permissions for each of the user's stack IDs.</p> </li>
    /// <li> <p>If the request contains a stack ID and an IAM ARN, the array contains a single <code>Permission</code> object with permissions for the specified stack and IAM ARN.</p> </li>
    /// </ul>
    #[doc(hidden)]
    pub permissions: std::option::Option<std::vec::Vec<crate::model::Permission>>,
}
impl DescribePermissionsOutput {
    /// <p>An array of <code>Permission</code> objects that describe the stack permissions.</p>
    /// <ul>
    /// <li> <p>If the request object contains only a stack ID, the array contains a <code>Permission</code> object with permissions for each of the stack IAM ARNs.</p> </li>
    /// <li> <p>If the request object contains only an IAM ARN, the array contains a <code>Permission</code> object with permissions for each of the user's stack IDs.</p> </li>
    /// <li> <p>If the request contains a stack ID and an IAM ARN, the array contains a single <code>Permission</code> object with permissions for the specified stack and IAM ARN.</p> </li>
    /// </ul>
    pub fn permissions(&self) -> std::option::Option<&[crate::model::Permission]> {
        self.permissions.as_deref()
    }
}
impl std::fmt::Debug for DescribePermissionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribePermissionsOutput");
        formatter.field("permissions", &self.permissions);
        formatter.finish()
    }
}
/// See [`DescribePermissionsOutput`](crate::output::DescribePermissionsOutput).
pub mod describe_permissions_output {

    /// A builder for [`DescribePermissionsOutput`](crate::output::DescribePermissionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) permissions: std::option::Option<std::vec::Vec<crate::model::Permission>>,
    }
    impl Builder {
        /// Appends an item to `permissions`.
        ///
        /// To override the contents of this collection use [`set_permissions`](Self::set_permissions).
        ///
        /// <p>An array of <code>Permission</code> objects that describe the stack permissions.</p>
        /// <ul>
        /// <li> <p>If the request object contains only a stack ID, the array contains a <code>Permission</code> object with permissions for each of the stack IAM ARNs.</p> </li>
        /// <li> <p>If the request object contains only an IAM ARN, the array contains a <code>Permission</code> object with permissions for each of the user's stack IDs.</p> </li>
        /// <li> <p>If the request contains a stack ID and an IAM ARN, the array contains a single <code>Permission</code> object with permissions for the specified stack and IAM ARN.</p> </li>
        /// </ul>
        pub fn permissions(mut self, input: crate::model::Permission) -> Self {
            let mut v = self.permissions.unwrap_or_default();
            v.push(input);
            self.permissions = Some(v);
            self
        }
        /// <p>An array of <code>Permission</code> objects that describe the stack permissions.</p>
        /// <ul>
        /// <li> <p>If the request object contains only a stack ID, the array contains a <code>Permission</code> object with permissions for each of the stack IAM ARNs.</p> </li>
        /// <li> <p>If the request object contains only an IAM ARN, the array contains a <code>Permission</code> object with permissions for each of the user's stack IDs.</p> </li>
        /// <li> <p>If the request contains a stack ID and an IAM ARN, the array contains a single <code>Permission</code> object with permissions for the specified stack and IAM ARN.</p> </li>
        /// </ul>
        pub fn set_permissions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Permission>>,
        ) -> Self {
            self.permissions = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribePermissionsOutput`](crate::output::DescribePermissionsOutput).
        pub fn build(self) -> crate::output::DescribePermissionsOutput {
            crate::output::DescribePermissionsOutput {
                permissions: self.permissions,
            }
        }
    }
}
impl DescribePermissionsOutput {
    /// Creates a new builder-style object to manufacture [`DescribePermissionsOutput`](crate::output::DescribePermissionsOutput).
    pub fn builder() -> crate::output::describe_permissions_output::Builder {
        crate::output::describe_permissions_output::Builder::default()
    }
}

/// <p>The response to a <code>DescribeOperatingSystems</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeOperatingSystemsOutput {
    /// <p>Contains information in response to a <code>DescribeOperatingSystems</code> request.</p>
    #[doc(hidden)]
    pub operating_systems: std::option::Option<std::vec::Vec<crate::model::OperatingSystem>>,
}
impl DescribeOperatingSystemsOutput {
    /// <p>Contains information in response to a <code>DescribeOperatingSystems</code> request.</p>
    pub fn operating_systems(&self) -> std::option::Option<&[crate::model::OperatingSystem]> {
        self.operating_systems.as_deref()
    }
}
impl std::fmt::Debug for DescribeOperatingSystemsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeOperatingSystemsOutput");
        formatter.field("operating_systems", &self.operating_systems);
        formatter.finish()
    }
}
/// See [`DescribeOperatingSystemsOutput`](crate::output::DescribeOperatingSystemsOutput).
pub mod describe_operating_systems_output {

    /// A builder for [`DescribeOperatingSystemsOutput`](crate::output::DescribeOperatingSystemsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) operating_systems:
            std::option::Option<std::vec::Vec<crate::model::OperatingSystem>>,
    }
    impl Builder {
        /// Appends an item to `operating_systems`.
        ///
        /// To override the contents of this collection use [`set_operating_systems`](Self::set_operating_systems).
        ///
        /// <p>Contains information in response to a <code>DescribeOperatingSystems</code> request.</p>
        pub fn operating_systems(mut self, input: crate::model::OperatingSystem) -> Self {
            let mut v = self.operating_systems.unwrap_or_default();
            v.push(input);
            self.operating_systems = Some(v);
            self
        }
        /// <p>Contains information in response to a <code>DescribeOperatingSystems</code> request.</p>
        pub fn set_operating_systems(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::OperatingSystem>>,
        ) -> Self {
            self.operating_systems = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeOperatingSystemsOutput`](crate::output::DescribeOperatingSystemsOutput).
        pub fn build(self) -> crate::output::DescribeOperatingSystemsOutput {
            crate::output::DescribeOperatingSystemsOutput {
                operating_systems: self.operating_systems,
            }
        }
    }
}
impl DescribeOperatingSystemsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeOperatingSystemsOutput`](crate::output::DescribeOperatingSystemsOutput).
    pub fn builder() -> crate::output::describe_operating_systems_output::Builder {
        crate::output::describe_operating_systems_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeMyUserProfile</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeMyUserProfileOutput {
    /// <p>A <code>UserProfile</code> object that describes the user's SSH information.</p>
    #[doc(hidden)]
    pub user_profile: std::option::Option<crate::model::SelfUserProfile>,
}
impl DescribeMyUserProfileOutput {
    /// <p>A <code>UserProfile</code> object that describes the user's SSH information.</p>
    pub fn user_profile(&self) -> std::option::Option<&crate::model::SelfUserProfile> {
        self.user_profile.as_ref()
    }
}
impl std::fmt::Debug for DescribeMyUserProfileOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeMyUserProfileOutput");
        formatter.field("user_profile", &self.user_profile);
        formatter.finish()
    }
}
/// See [`DescribeMyUserProfileOutput`](crate::output::DescribeMyUserProfileOutput).
pub mod describe_my_user_profile_output {

    /// A builder for [`DescribeMyUserProfileOutput`](crate::output::DescribeMyUserProfileOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) user_profile: std::option::Option<crate::model::SelfUserProfile>,
    }
    impl Builder {
        /// <p>A <code>UserProfile</code> object that describes the user's SSH information.</p>
        pub fn user_profile(mut self, input: crate::model::SelfUserProfile) -> Self {
            self.user_profile = Some(input);
            self
        }
        /// <p>A <code>UserProfile</code> object that describes the user's SSH information.</p>
        pub fn set_user_profile(
            mut self,
            input: std::option::Option<crate::model::SelfUserProfile>,
        ) -> Self {
            self.user_profile = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeMyUserProfileOutput`](crate::output::DescribeMyUserProfileOutput).
        pub fn build(self) -> crate::output::DescribeMyUserProfileOutput {
            crate::output::DescribeMyUserProfileOutput {
                user_profile: self.user_profile,
            }
        }
    }
}
impl DescribeMyUserProfileOutput {
    /// Creates a new builder-style object to manufacture [`DescribeMyUserProfileOutput`](crate::output::DescribeMyUserProfileOutput).
    pub fn builder() -> crate::output::describe_my_user_profile_output::Builder {
        crate::output::describe_my_user_profile_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeLoadBasedAutoScaling</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeLoadBasedAutoScalingOutput {
    /// <p>An array of <code>LoadBasedAutoScalingConfiguration</code> objects that describe each layer's configuration.</p>
    #[doc(hidden)]
    pub load_based_auto_scaling_configurations:
        std::option::Option<std::vec::Vec<crate::model::LoadBasedAutoScalingConfiguration>>,
}
impl DescribeLoadBasedAutoScalingOutput {
    /// <p>An array of <code>LoadBasedAutoScalingConfiguration</code> objects that describe each layer's configuration.</p>
    pub fn load_based_auto_scaling_configurations(
        &self,
    ) -> std::option::Option<&[crate::model::LoadBasedAutoScalingConfiguration]> {
        self.load_based_auto_scaling_configurations.as_deref()
    }
}
impl std::fmt::Debug for DescribeLoadBasedAutoScalingOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeLoadBasedAutoScalingOutput");
        formatter.field(
            "load_based_auto_scaling_configurations",
            &self.load_based_auto_scaling_configurations,
        );
        formatter.finish()
    }
}
/// See [`DescribeLoadBasedAutoScalingOutput`](crate::output::DescribeLoadBasedAutoScalingOutput).
pub mod describe_load_based_auto_scaling_output {

    /// A builder for [`DescribeLoadBasedAutoScalingOutput`](crate::output::DescribeLoadBasedAutoScalingOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) load_based_auto_scaling_configurations:
            std::option::Option<std::vec::Vec<crate::model::LoadBasedAutoScalingConfiguration>>,
    }
    impl Builder {
        /// Appends an item to `load_based_auto_scaling_configurations`.
        ///
        /// To override the contents of this collection use [`set_load_based_auto_scaling_configurations`](Self::set_load_based_auto_scaling_configurations).
        ///
        /// <p>An array of <code>LoadBasedAutoScalingConfiguration</code> objects that describe each layer's configuration.</p>
        pub fn load_based_auto_scaling_configurations(
            mut self,
            input: crate::model::LoadBasedAutoScalingConfiguration,
        ) -> Self {
            let mut v = self
                .load_based_auto_scaling_configurations
                .unwrap_or_default();
            v.push(input);
            self.load_based_auto_scaling_configurations = Some(v);
            self
        }
        /// <p>An array of <code>LoadBasedAutoScalingConfiguration</code> objects that describe each layer's configuration.</p>
        pub fn set_load_based_auto_scaling_configurations(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::LoadBasedAutoScalingConfiguration>,
            >,
        ) -> Self {
            self.load_based_auto_scaling_configurations = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeLoadBasedAutoScalingOutput`](crate::output::DescribeLoadBasedAutoScalingOutput).
        pub fn build(self) -> crate::output::DescribeLoadBasedAutoScalingOutput {
            crate::output::DescribeLoadBasedAutoScalingOutput {
                load_based_auto_scaling_configurations: self.load_based_auto_scaling_configurations,
            }
        }
    }
}
impl DescribeLoadBasedAutoScalingOutput {
    /// Creates a new builder-style object to manufacture [`DescribeLoadBasedAutoScalingOutput`](crate::output::DescribeLoadBasedAutoScalingOutput).
    pub fn builder() -> crate::output::describe_load_based_auto_scaling_output::Builder {
        crate::output::describe_load_based_auto_scaling_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeLayers</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeLayersOutput {
    /// <p>An array of <code>Layer</code> objects that describe the layers.</p>
    #[doc(hidden)]
    pub layers: std::option::Option<std::vec::Vec<crate::model::Layer>>,
}
impl DescribeLayersOutput {
    /// <p>An array of <code>Layer</code> objects that describe the layers.</p>
    pub fn layers(&self) -> std::option::Option<&[crate::model::Layer]> {
        self.layers.as_deref()
    }
}
impl std::fmt::Debug for DescribeLayersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeLayersOutput");
        formatter.field("layers", &self.layers);
        formatter.finish()
    }
}
/// See [`DescribeLayersOutput`](crate::output::DescribeLayersOutput).
pub mod describe_layers_output {

    /// A builder for [`DescribeLayersOutput`](crate::output::DescribeLayersOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) layers: std::option::Option<std::vec::Vec<crate::model::Layer>>,
    }
    impl Builder {
        /// Appends an item to `layers`.
        ///
        /// To override the contents of this collection use [`set_layers`](Self::set_layers).
        ///
        /// <p>An array of <code>Layer</code> objects that describe the layers.</p>
        pub fn layers(mut self, input: crate::model::Layer) -> Self {
            let mut v = self.layers.unwrap_or_default();
            v.push(input);
            self.layers = Some(v);
            self
        }
        /// <p>An array of <code>Layer</code> objects that describe the layers.</p>
        pub fn set_layers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Layer>>,
        ) -> Self {
            self.layers = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeLayersOutput`](crate::output::DescribeLayersOutput).
        pub fn build(self) -> crate::output::DescribeLayersOutput {
            crate::output::DescribeLayersOutput {
                layers: self.layers,
            }
        }
    }
}
impl DescribeLayersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeLayersOutput`](crate::output::DescribeLayersOutput).
    pub fn builder() -> crate::output::describe_layers_output::Builder {
        crate::output::describe_layers_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeInstances</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeInstancesOutput {
    /// <p>An array of <code>Instance</code> objects that describe the instances.</p>
    #[doc(hidden)]
    pub instances: std::option::Option<std::vec::Vec<crate::model::Instance>>,
}
impl DescribeInstancesOutput {
    /// <p>An array of <code>Instance</code> objects that describe the instances.</p>
    pub fn instances(&self) -> std::option::Option<&[crate::model::Instance]> {
        self.instances.as_deref()
    }
}
impl std::fmt::Debug for DescribeInstancesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeInstancesOutput");
        formatter.field("instances", &self.instances);
        formatter.finish()
    }
}
/// See [`DescribeInstancesOutput`](crate::output::DescribeInstancesOutput).
pub mod describe_instances_output {

    /// A builder for [`DescribeInstancesOutput`](crate::output::DescribeInstancesOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) instances: std::option::Option<std::vec::Vec<crate::model::Instance>>,
    }
    impl Builder {
        /// Appends an item to `instances`.
        ///
        /// To override the contents of this collection use [`set_instances`](Self::set_instances).
        ///
        /// <p>An array of <code>Instance</code> objects that describe the instances.</p>
        pub fn instances(mut self, input: crate::model::Instance) -> Self {
            let mut v = self.instances.unwrap_or_default();
            v.push(input);
            self.instances = Some(v);
            self
        }
        /// <p>An array of <code>Instance</code> objects that describe the instances.</p>
        pub fn set_instances(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Instance>>,
        ) -> Self {
            self.instances = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeInstancesOutput`](crate::output::DescribeInstancesOutput).
        pub fn build(self) -> crate::output::DescribeInstancesOutput {
            crate::output::DescribeInstancesOutput {
                instances: self.instances,
            }
        }
    }
}
impl DescribeInstancesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeInstancesOutput`](crate::output::DescribeInstancesOutput).
    pub fn builder() -> crate::output::describe_instances_output::Builder {
        crate::output::describe_instances_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeElasticLoadBalancers</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeElasticLoadBalancersOutput {
    /// <p>A list of <code>ElasticLoadBalancer</code> objects that describe the specified Elastic Load Balancing instances.</p>
    #[doc(hidden)]
    pub elastic_load_balancers:
        std::option::Option<std::vec::Vec<crate::model::ElasticLoadBalancer>>,
}
impl DescribeElasticLoadBalancersOutput {
    /// <p>A list of <code>ElasticLoadBalancer</code> objects that describe the specified Elastic Load Balancing instances.</p>
    pub fn elastic_load_balancers(
        &self,
    ) -> std::option::Option<&[crate::model::ElasticLoadBalancer]> {
        self.elastic_load_balancers.as_deref()
    }
}
impl std::fmt::Debug for DescribeElasticLoadBalancersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeElasticLoadBalancersOutput");
        formatter.field("elastic_load_balancers", &self.elastic_load_balancers);
        formatter.finish()
    }
}
/// See [`DescribeElasticLoadBalancersOutput`](crate::output::DescribeElasticLoadBalancersOutput).
pub mod describe_elastic_load_balancers_output {

    /// A builder for [`DescribeElasticLoadBalancersOutput`](crate::output::DescribeElasticLoadBalancersOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) elastic_load_balancers:
            std::option::Option<std::vec::Vec<crate::model::ElasticLoadBalancer>>,
    }
    impl Builder {
        /// Appends an item to `elastic_load_balancers`.
        ///
        /// To override the contents of this collection use [`set_elastic_load_balancers`](Self::set_elastic_load_balancers).
        ///
        /// <p>A list of <code>ElasticLoadBalancer</code> objects that describe the specified Elastic Load Balancing instances.</p>
        pub fn elastic_load_balancers(mut self, input: crate::model::ElasticLoadBalancer) -> Self {
            let mut v = self.elastic_load_balancers.unwrap_or_default();
            v.push(input);
            self.elastic_load_balancers = Some(v);
            self
        }
        /// <p>A list of <code>ElasticLoadBalancer</code> objects that describe the specified Elastic Load Balancing instances.</p>
        pub fn set_elastic_load_balancers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ElasticLoadBalancer>>,
        ) -> Self {
            self.elastic_load_balancers = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeElasticLoadBalancersOutput`](crate::output::DescribeElasticLoadBalancersOutput).
        pub fn build(self) -> crate::output::DescribeElasticLoadBalancersOutput {
            crate::output::DescribeElasticLoadBalancersOutput {
                elastic_load_balancers: self.elastic_load_balancers,
            }
        }
    }
}
impl DescribeElasticLoadBalancersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeElasticLoadBalancersOutput`](crate::output::DescribeElasticLoadBalancersOutput).
    pub fn builder() -> crate::output::describe_elastic_load_balancers_output::Builder {
        crate::output::describe_elastic_load_balancers_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeElasticIps</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeElasticIpsOutput {
    /// <p>An <code>ElasticIps</code> object that describes the specified Elastic IP addresses.</p>
    #[doc(hidden)]
    pub elastic_ips: std::option::Option<std::vec::Vec<crate::model::ElasticIp>>,
}
impl DescribeElasticIpsOutput {
    /// <p>An <code>ElasticIps</code> object that describes the specified Elastic IP addresses.</p>
    pub fn elastic_ips(&self) -> std::option::Option<&[crate::model::ElasticIp]> {
        self.elastic_ips.as_deref()
    }
}
impl std::fmt::Debug for DescribeElasticIpsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeElasticIpsOutput");
        formatter.field("elastic_ips", &self.elastic_ips);
        formatter.finish()
    }
}
/// See [`DescribeElasticIpsOutput`](crate::output::DescribeElasticIpsOutput).
pub mod describe_elastic_ips_output {

    /// A builder for [`DescribeElasticIpsOutput`](crate::output::DescribeElasticIpsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) elastic_ips: std::option::Option<std::vec::Vec<crate::model::ElasticIp>>,
    }
    impl Builder {
        /// Appends an item to `elastic_ips`.
        ///
        /// To override the contents of this collection use [`set_elastic_ips`](Self::set_elastic_ips).
        ///
        /// <p>An <code>ElasticIps</code> object that describes the specified Elastic IP addresses.</p>
        pub fn elastic_ips(mut self, input: crate::model::ElasticIp) -> Self {
            let mut v = self.elastic_ips.unwrap_or_default();
            v.push(input);
            self.elastic_ips = Some(v);
            self
        }
        /// <p>An <code>ElasticIps</code> object that describes the specified Elastic IP addresses.</p>
        pub fn set_elastic_ips(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ElasticIp>>,
        ) -> Self {
            self.elastic_ips = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeElasticIpsOutput`](crate::output::DescribeElasticIpsOutput).
        pub fn build(self) -> crate::output::DescribeElasticIpsOutput {
            crate::output::DescribeElasticIpsOutput {
                elastic_ips: self.elastic_ips,
            }
        }
    }
}
impl DescribeElasticIpsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeElasticIpsOutput`](crate::output::DescribeElasticIpsOutput).
    pub fn builder() -> crate::output::describe_elastic_ips_output::Builder {
        crate::output::describe_elastic_ips_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeEcsClusters</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEcsClustersOutput {
    /// <p>A list of <code>EcsCluster</code> objects containing the cluster descriptions.</p>
    #[doc(hidden)]
    pub ecs_clusters: std::option::Option<std::vec::Vec<crate::model::EcsCluster>>,
    /// <p>If a paginated request does not return all of the remaining results, this parameter is set to a token that you can assign to the request object's <code>NextToken</code> parameter to retrieve the next set of results. If the previous paginated request returned all of the remaining results, this parameter is set to <code>null</code>.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeEcsClustersOutput {
    /// <p>A list of <code>EcsCluster</code> objects containing the cluster descriptions.</p>
    pub fn ecs_clusters(&self) -> std::option::Option<&[crate::model::EcsCluster]> {
        self.ecs_clusters.as_deref()
    }
    /// <p>If a paginated request does not return all of the remaining results, this parameter is set to a token that you can assign to the request object's <code>NextToken</code> parameter to retrieve the next set of results. If the previous paginated request returned all of the remaining results, this parameter is set to <code>null</code>.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeEcsClustersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEcsClustersOutput");
        formatter.field("ecs_clusters", &self.ecs_clusters);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeEcsClustersOutput`](crate::output::DescribeEcsClustersOutput).
pub mod describe_ecs_clusters_output {

    /// A builder for [`DescribeEcsClustersOutput`](crate::output::DescribeEcsClustersOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) ecs_clusters: std::option::Option<std::vec::Vec<crate::model::EcsCluster>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `ecs_clusters`.
        ///
        /// To override the contents of this collection use [`set_ecs_clusters`](Self::set_ecs_clusters).
        ///
        /// <p>A list of <code>EcsCluster</code> objects containing the cluster descriptions.</p>
        pub fn ecs_clusters(mut self, input: crate::model::EcsCluster) -> Self {
            let mut v = self.ecs_clusters.unwrap_or_default();
            v.push(input);
            self.ecs_clusters = Some(v);
            self
        }
        /// <p>A list of <code>EcsCluster</code> objects containing the cluster descriptions.</p>
        pub fn set_ecs_clusters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EcsCluster>>,
        ) -> Self {
            self.ecs_clusters = input;
            self
        }
        /// <p>If a paginated request does not return all of the remaining results, this parameter is set to a token that you can assign to the request object's <code>NextToken</code> parameter to retrieve the next set of results. If the previous paginated request returned all of the remaining results, this parameter is set to <code>null</code>.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>If a paginated request does not return all of the remaining results, this parameter is set to a token that you can assign to the request object's <code>NextToken</code> parameter to retrieve the next set of results. If the previous paginated request returned all of the remaining results, this parameter is set to <code>null</code>.</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 [`DescribeEcsClustersOutput`](crate::output::DescribeEcsClustersOutput).
        pub fn build(self) -> crate::output::DescribeEcsClustersOutput {
            crate::output::DescribeEcsClustersOutput {
                ecs_clusters: self.ecs_clusters,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeEcsClustersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEcsClustersOutput`](crate::output::DescribeEcsClustersOutput).
    pub fn builder() -> crate::output::describe_ecs_clusters_output::Builder {
        crate::output::describe_ecs_clusters_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeDeployments</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeDeploymentsOutput {
    /// <p>An array of <code>Deployment</code> objects that describe the deployments.</p>
    #[doc(hidden)]
    pub deployments: std::option::Option<std::vec::Vec<crate::model::Deployment>>,
}
impl DescribeDeploymentsOutput {
    /// <p>An array of <code>Deployment</code> objects that describe the deployments.</p>
    pub fn deployments(&self) -> std::option::Option<&[crate::model::Deployment]> {
        self.deployments.as_deref()
    }
}
impl std::fmt::Debug for DescribeDeploymentsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeDeploymentsOutput");
        formatter.field("deployments", &self.deployments);
        formatter.finish()
    }
}
/// See [`DescribeDeploymentsOutput`](crate::output::DescribeDeploymentsOutput).
pub mod describe_deployments_output {

    /// A builder for [`DescribeDeploymentsOutput`](crate::output::DescribeDeploymentsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) deployments: std::option::Option<std::vec::Vec<crate::model::Deployment>>,
    }
    impl Builder {
        /// Appends an item to `deployments`.
        ///
        /// To override the contents of this collection use [`set_deployments`](Self::set_deployments).
        ///
        /// <p>An array of <code>Deployment</code> objects that describe the deployments.</p>
        pub fn deployments(mut self, input: crate::model::Deployment) -> Self {
            let mut v = self.deployments.unwrap_or_default();
            v.push(input);
            self.deployments = Some(v);
            self
        }
        /// <p>An array of <code>Deployment</code> objects that describe the deployments.</p>
        pub fn set_deployments(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Deployment>>,
        ) -> Self {
            self.deployments = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeDeploymentsOutput`](crate::output::DescribeDeploymentsOutput).
        pub fn build(self) -> crate::output::DescribeDeploymentsOutput {
            crate::output::DescribeDeploymentsOutput {
                deployments: self.deployments,
            }
        }
    }
}
impl DescribeDeploymentsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeDeploymentsOutput`](crate::output::DescribeDeploymentsOutput).
    pub fn builder() -> crate::output::describe_deployments_output::Builder {
        crate::output::describe_deployments_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeCommands</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeCommandsOutput {
    /// <p>An array of <code>Command</code> objects that describe each of the specified commands.</p>
    #[doc(hidden)]
    pub commands: std::option::Option<std::vec::Vec<crate::model::Command>>,
}
impl DescribeCommandsOutput {
    /// <p>An array of <code>Command</code> objects that describe each of the specified commands.</p>
    pub fn commands(&self) -> std::option::Option<&[crate::model::Command]> {
        self.commands.as_deref()
    }
}
impl std::fmt::Debug for DescribeCommandsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeCommandsOutput");
        formatter.field("commands", &self.commands);
        formatter.finish()
    }
}
/// See [`DescribeCommandsOutput`](crate::output::DescribeCommandsOutput).
pub mod describe_commands_output {

    /// A builder for [`DescribeCommandsOutput`](crate::output::DescribeCommandsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) commands: std::option::Option<std::vec::Vec<crate::model::Command>>,
    }
    impl Builder {
        /// Appends an item to `commands`.
        ///
        /// To override the contents of this collection use [`set_commands`](Self::set_commands).
        ///
        /// <p>An array of <code>Command</code> objects that describe each of the specified commands.</p>
        pub fn commands(mut self, input: crate::model::Command) -> Self {
            let mut v = self.commands.unwrap_or_default();
            v.push(input);
            self.commands = Some(v);
            self
        }
        /// <p>An array of <code>Command</code> objects that describe each of the specified commands.</p>
        pub fn set_commands(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Command>>,
        ) -> Self {
            self.commands = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeCommandsOutput`](crate::output::DescribeCommandsOutput).
        pub fn build(self) -> crate::output::DescribeCommandsOutput {
            crate::output::DescribeCommandsOutput {
                commands: self.commands,
            }
        }
    }
}
impl DescribeCommandsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeCommandsOutput`](crate::output::DescribeCommandsOutput).
    pub fn builder() -> crate::output::describe_commands_output::Builder {
        crate::output::describe_commands_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeApps</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAppsOutput {
    /// <p>An array of <code>App</code> objects that describe the specified apps. </p>
    #[doc(hidden)]
    pub apps: std::option::Option<std::vec::Vec<crate::model::App>>,
}
impl DescribeAppsOutput {
    /// <p>An array of <code>App</code> objects that describe the specified apps. </p>
    pub fn apps(&self) -> std::option::Option<&[crate::model::App]> {
        self.apps.as_deref()
    }
}
impl std::fmt::Debug for DescribeAppsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAppsOutput");
        formatter.field("apps", &self.apps);
        formatter.finish()
    }
}
/// See [`DescribeAppsOutput`](crate::output::DescribeAppsOutput).
pub mod describe_apps_output {

    /// A builder for [`DescribeAppsOutput`](crate::output::DescribeAppsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) apps: std::option::Option<std::vec::Vec<crate::model::App>>,
    }
    impl Builder {
        /// Appends an item to `apps`.
        ///
        /// To override the contents of this collection use [`set_apps`](Self::set_apps).
        ///
        /// <p>An array of <code>App</code> objects that describe the specified apps. </p>
        pub fn apps(mut self, input: crate::model::App) -> Self {
            let mut v = self.apps.unwrap_or_default();
            v.push(input);
            self.apps = Some(v);
            self
        }
        /// <p>An array of <code>App</code> objects that describe the specified apps. </p>
        pub fn set_apps(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::App>>,
        ) -> Self {
            self.apps = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAppsOutput`](crate::output::DescribeAppsOutput).
        pub fn build(self) -> crate::output::DescribeAppsOutput {
            crate::output::DescribeAppsOutput { apps: self.apps }
        }
    }
}
impl DescribeAppsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAppsOutput`](crate::output::DescribeAppsOutput).
    pub fn builder() -> crate::output::describe_apps_output::Builder {
        crate::output::describe_apps_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>DescribeAgentVersions</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAgentVersionsOutput {
    /// <p>The agent versions for the specified stack or configuration manager. Note that this value is the complete version number, not the abbreviated number used by the console.</p>
    #[doc(hidden)]
    pub agent_versions: std::option::Option<std::vec::Vec<crate::model::AgentVersion>>,
}
impl DescribeAgentVersionsOutput {
    /// <p>The agent versions for the specified stack or configuration manager. Note that this value is the complete version number, not the abbreviated number used by the console.</p>
    pub fn agent_versions(&self) -> std::option::Option<&[crate::model::AgentVersion]> {
        self.agent_versions.as_deref()
    }
}
impl std::fmt::Debug for DescribeAgentVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAgentVersionsOutput");
        formatter.field("agent_versions", &self.agent_versions);
        formatter.finish()
    }
}
/// See [`DescribeAgentVersionsOutput`](crate::output::DescribeAgentVersionsOutput).
pub mod describe_agent_versions_output {

    /// A builder for [`DescribeAgentVersionsOutput`](crate::output::DescribeAgentVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) agent_versions: std::option::Option<std::vec::Vec<crate::model::AgentVersion>>,
    }
    impl Builder {
        /// Appends an item to `agent_versions`.
        ///
        /// To override the contents of this collection use [`set_agent_versions`](Self::set_agent_versions).
        ///
        /// <p>The agent versions for the specified stack or configuration manager. Note that this value is the complete version number, not the abbreviated number used by the console.</p>
        pub fn agent_versions(mut self, input: crate::model::AgentVersion) -> Self {
            let mut v = self.agent_versions.unwrap_or_default();
            v.push(input);
            self.agent_versions = Some(v);
            self
        }
        /// <p>The agent versions for the specified stack or configuration manager. Note that this value is the complete version number, not the abbreviated number used by the console.</p>
        pub fn set_agent_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AgentVersion>>,
        ) -> Self {
            self.agent_versions = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAgentVersionsOutput`](crate::output::DescribeAgentVersionsOutput).
        pub fn build(self) -> crate::output::DescribeAgentVersionsOutput {
            crate::output::DescribeAgentVersionsOutput {
                agent_versions: self.agent_versions,
            }
        }
    }
}
impl DescribeAgentVersionsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAgentVersionsOutput`](crate::output::DescribeAgentVersionsOutput).
    pub fn builder() -> crate::output::describe_agent_versions_output::Builder {
        crate::output::describe_agent_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterVolumeOutput {}
impl std::fmt::Debug for DeregisterVolumeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterVolumeOutput");
        formatter.finish()
    }
}
/// See [`DeregisterVolumeOutput`](crate::output::DeregisterVolumeOutput).
pub mod deregister_volume_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterRdsDbInstanceOutput {}
impl std::fmt::Debug for DeregisterRdsDbInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterRdsDbInstanceOutput");
        formatter.finish()
    }
}
/// See [`DeregisterRdsDbInstanceOutput`](crate::output::DeregisterRdsDbInstanceOutput).
pub mod deregister_rds_db_instance_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterInstanceOutput {}
impl std::fmt::Debug for DeregisterInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterInstanceOutput");
        formatter.finish()
    }
}
/// See [`DeregisterInstanceOutput`](crate::output::DeregisterInstanceOutput).
pub mod deregister_instance_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterElasticIpOutput {}
impl std::fmt::Debug for DeregisterElasticIpOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterElasticIpOutput");
        formatter.finish()
    }
}
/// See [`DeregisterElasticIpOutput`](crate::output::DeregisterElasticIpOutput).
pub mod deregister_elastic_ip_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeregisterEcsClusterOutput {}
impl std::fmt::Debug for DeregisterEcsClusterOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeregisterEcsClusterOutput");
        formatter.finish()
    }
}
/// See [`DeregisterEcsClusterOutput`](crate::output::DeregisterEcsClusterOutput).
pub mod deregister_ecs_cluster_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteUserProfileOutput {}
impl std::fmt::Debug for DeleteUserProfileOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteUserProfileOutput");
        formatter.finish()
    }
}
/// See [`DeleteUserProfileOutput`](crate::output::DeleteUserProfileOutput).
pub mod delete_user_profile_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteStackOutput {}
impl std::fmt::Debug for DeleteStackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteStackOutput");
        formatter.finish()
    }
}
/// See [`DeleteStackOutput`](crate::output::DeleteStackOutput).
pub mod delete_stack_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteLayerOutput {}
impl std::fmt::Debug for DeleteLayerOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteLayerOutput");
        formatter.finish()
    }
}
/// See [`DeleteLayerOutput`](crate::output::DeleteLayerOutput).
pub mod delete_layer_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteInstanceOutput {}
impl std::fmt::Debug for DeleteInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteInstanceOutput");
        formatter.finish()
    }
}
/// See [`DeleteInstanceOutput`](crate::output::DeleteInstanceOutput).
pub mod delete_instance_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteAppOutput {}
impl std::fmt::Debug for DeleteAppOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteAppOutput");
        formatter.finish()
    }
}
/// See [`DeleteAppOutput`](crate::output::DeleteAppOutput).
pub mod delete_app_output {

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

/// <p>Contains the response to a <code>CreateUserProfile</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateUserProfileOutput {
    /// <p>The user's IAM ARN.</p>
    #[doc(hidden)]
    pub iam_user_arn: std::option::Option<std::string::String>,
}
impl CreateUserProfileOutput {
    /// <p>The user's IAM ARN.</p>
    pub fn iam_user_arn(&self) -> std::option::Option<&str> {
        self.iam_user_arn.as_deref()
    }
}
impl std::fmt::Debug for CreateUserProfileOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateUserProfileOutput");
        formatter.field("iam_user_arn", &self.iam_user_arn);
        formatter.finish()
    }
}
/// See [`CreateUserProfileOutput`](crate::output::CreateUserProfileOutput).
pub mod create_user_profile_output {

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

/// <p>Contains the response to a <code>CreateStack</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateStackOutput {
    /// <p>The stack ID, which is an opaque string that you use to identify the stack when performing actions such as <code>DescribeStacks</code>.</p>
    #[doc(hidden)]
    pub stack_id: std::option::Option<std::string::String>,
}
impl CreateStackOutput {
    /// <p>The stack ID, which is an opaque string that you use to identify the stack when performing actions such as <code>DescribeStacks</code>.</p>
    pub fn stack_id(&self) -> std::option::Option<&str> {
        self.stack_id.as_deref()
    }
}
impl std::fmt::Debug for CreateStackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateStackOutput");
        formatter.field("stack_id", &self.stack_id);
        formatter.finish()
    }
}
/// See [`CreateStackOutput`](crate::output::CreateStackOutput).
pub mod create_stack_output {

    /// A builder for [`CreateStackOutput`](crate::output::CreateStackOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) stack_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The stack ID, which is an opaque string that you use to identify the stack when performing actions such as <code>DescribeStacks</code>.</p>
        pub fn stack_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.stack_id = Some(input.into());
            self
        }
        /// <p>The stack ID, which is an opaque string that you use to identify the stack when performing actions such as <code>DescribeStacks</code>.</p>
        pub fn set_stack_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.stack_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateStackOutput`](crate::output::CreateStackOutput).
        pub fn build(self) -> crate::output::CreateStackOutput {
            crate::output::CreateStackOutput {
                stack_id: self.stack_id,
            }
        }
    }
}
impl CreateStackOutput {
    /// Creates a new builder-style object to manufacture [`CreateStackOutput`](crate::output::CreateStackOutput).
    pub fn builder() -> crate::output::create_stack_output::Builder {
        crate::output::create_stack_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>CreateLayer</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateLayerOutput {
    /// <p>The layer ID.</p>
    #[doc(hidden)]
    pub layer_id: std::option::Option<std::string::String>,
}
impl CreateLayerOutput {
    /// <p>The layer ID.</p>
    pub fn layer_id(&self) -> std::option::Option<&str> {
        self.layer_id.as_deref()
    }
}
impl std::fmt::Debug for CreateLayerOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateLayerOutput");
        formatter.field("layer_id", &self.layer_id);
        formatter.finish()
    }
}
/// See [`CreateLayerOutput`](crate::output::CreateLayerOutput).
pub mod create_layer_output {

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

/// <p>Contains the response to a <code>CreateInstance</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateInstanceOutput {
    /// <p>The instance ID.</p>
    #[doc(hidden)]
    pub instance_id: std::option::Option<std::string::String>,
}
impl CreateInstanceOutput {
    /// <p>The instance ID.</p>
    pub fn instance_id(&self) -> std::option::Option<&str> {
        self.instance_id.as_deref()
    }
}
impl std::fmt::Debug for CreateInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateInstanceOutput");
        formatter.field("instance_id", &self.instance_id);
        formatter.finish()
    }
}
/// See [`CreateInstanceOutput`](crate::output::CreateInstanceOutput).
pub mod create_instance_output {

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

/// <p>Contains the response to a <code>CreateDeployment</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateDeploymentOutput {
    /// <p>The deployment ID, which can be used with other requests to identify the deployment.</p>
    #[doc(hidden)]
    pub deployment_id: std::option::Option<std::string::String>,
}
impl CreateDeploymentOutput {
    /// <p>The deployment ID, which can be used with other requests to identify the deployment.</p>
    pub fn deployment_id(&self) -> std::option::Option<&str> {
        self.deployment_id.as_deref()
    }
}
impl std::fmt::Debug for CreateDeploymentOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateDeploymentOutput");
        formatter.field("deployment_id", &self.deployment_id);
        formatter.finish()
    }
}
/// See [`CreateDeploymentOutput`](crate::output::CreateDeploymentOutput).
pub mod create_deployment_output {

    /// A builder for [`CreateDeploymentOutput`](crate::output::CreateDeploymentOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) deployment_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The deployment ID, which can be used with other requests to identify the deployment.</p>
        pub fn deployment_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.deployment_id = Some(input.into());
            self
        }
        /// <p>The deployment ID, which can be used with other requests to identify the deployment.</p>
        pub fn set_deployment_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.deployment_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateDeploymentOutput`](crate::output::CreateDeploymentOutput).
        pub fn build(self) -> crate::output::CreateDeploymentOutput {
            crate::output::CreateDeploymentOutput {
                deployment_id: self.deployment_id,
            }
        }
    }
}
impl CreateDeploymentOutput {
    /// Creates a new builder-style object to manufacture [`CreateDeploymentOutput`](crate::output::CreateDeploymentOutput).
    pub fn builder() -> crate::output::create_deployment_output::Builder {
        crate::output::create_deployment_output::Builder::default()
    }
}

/// <p>Contains the response to a <code>CreateApp</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateAppOutput {
    /// <p>The app ID.</p>
    #[doc(hidden)]
    pub app_id: std::option::Option<std::string::String>,
}
impl CreateAppOutput {
    /// <p>The app ID.</p>
    pub fn app_id(&self) -> std::option::Option<&str> {
        self.app_id.as_deref()
    }
}
impl std::fmt::Debug for CreateAppOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateAppOutput");
        formatter.field("app_id", &self.app_id);
        formatter.finish()
    }
}
/// See [`CreateAppOutput`](crate::output::CreateAppOutput).
pub mod create_app_output {

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

/// <p>Contains the response to a <code>CloneStack</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CloneStackOutput {
    /// <p>The cloned stack ID.</p>
    #[doc(hidden)]
    pub stack_id: std::option::Option<std::string::String>,
}
impl CloneStackOutput {
    /// <p>The cloned stack ID.</p>
    pub fn stack_id(&self) -> std::option::Option<&str> {
        self.stack_id.as_deref()
    }
}
impl std::fmt::Debug for CloneStackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CloneStackOutput");
        formatter.field("stack_id", &self.stack_id);
        formatter.finish()
    }
}
/// See [`CloneStackOutput`](crate::output::CloneStackOutput).
pub mod clone_stack_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AttachElasticLoadBalancerOutput {}
impl std::fmt::Debug for AttachElasticLoadBalancerOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("AttachElasticLoadBalancerOutput");
        formatter.finish()
    }
}
/// See [`AttachElasticLoadBalancerOutput`](crate::output::AttachElasticLoadBalancerOutput).
pub mod attach_elastic_load_balancer_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateElasticIpOutput {}
impl std::fmt::Debug for AssociateElasticIpOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("AssociateElasticIpOutput");
        formatter.finish()
    }
}
/// See [`AssociateElasticIpOutput`](crate::output::AssociateElasticIpOutput).
pub mod associate_elastic_ip_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssignVolumeOutput {}
impl std::fmt::Debug for AssignVolumeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("AssignVolumeOutput");
        formatter.finish()
    }
}
/// See [`AssignVolumeOutput`](crate::output::AssignVolumeOutput).
pub mod assign_volume_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssignInstanceOutput {}
impl std::fmt::Debug for AssignInstanceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("AssignInstanceOutput");
        formatter.finish()
    }
}
/// See [`AssignInstanceOutput`](crate::output::AssignInstanceOutput).
pub mod assign_instance_output {

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