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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListLongTermPricingOutput {
    /// <p>Each <code>LongTermPricingEntry</code> object contains a status, ID, and other information
    /// about the <code>LongTermPricing</code> type. </p>
    pub long_term_pricing_entries:
        std::option::Option<std::vec::Vec<crate::model::LongTermPricingListEntry>>,
    /// <p>Because HTTP requests are stateless, this is the starting point for your next list of
    /// returned <code>ListLongTermPricing</code> list.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListLongTermPricingOutput {
    /// <p>Each <code>LongTermPricingEntry</code> object contains a status, ID, and other information
    /// about the <code>LongTermPricing</code> type. </p>
    pub fn long_term_pricing_entries(
        &self,
    ) -> std::option::Option<&[crate::model::LongTermPricingListEntry]> {
        self.long_term_pricing_entries.as_deref()
    }
    /// <p>Because HTTP requests are stateless, this is the starting point for your next list of
    /// returned <code>ListLongTermPricing</code> list.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListLongTermPricingOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListLongTermPricingOutput");
        formatter.field("long_term_pricing_entries", &self.long_term_pricing_entries);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListLongTermPricingOutput`](crate::output::ListLongTermPricingOutput)
pub mod list_long_term_pricing_output {
    /// A builder for [`ListLongTermPricingOutput`](crate::output::ListLongTermPricingOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) long_term_pricing_entries:
            std::option::Option<std::vec::Vec<crate::model::LongTermPricingListEntry>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `long_term_pricing_entries`.
        ///
        /// To override the contents of this collection use [`set_long_term_pricing_entries`](Self::set_long_term_pricing_entries).
        ///
        /// <p>Each <code>LongTermPricingEntry</code> object contains a status, ID, and other information
        /// about the <code>LongTermPricing</code> type. </p>
        pub fn long_term_pricing_entries(
            mut self,
            input: impl Into<crate::model::LongTermPricingListEntry>,
        ) -> Self {
            let mut v = self.long_term_pricing_entries.unwrap_or_default();
            v.push(input.into());
            self.long_term_pricing_entries = Some(v);
            self
        }
        /// <p>Each <code>LongTermPricingEntry</code> object contains a status, ID, and other information
        /// about the <code>LongTermPricing</code> type. </p>
        pub fn set_long_term_pricing_entries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::LongTermPricingListEntry>>,
        ) -> Self {
            self.long_term_pricing_entries = input;
            self
        }
        /// <p>Because HTTP requests are stateless, this is the starting point for your next list of
        /// returned <code>ListLongTermPricing</code> list.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>Because HTTP requests are stateless, this is the starting point for your next list of
        /// returned <code>ListLongTermPricing</code> list.</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 [`ListLongTermPricingOutput`](crate::output::ListLongTermPricingOutput)
        pub fn build(self) -> crate::output::ListLongTermPricingOutput {
            crate::output::ListLongTermPricingOutput {
                long_term_pricing_entries: self.long_term_pricing_entries,
                next_token: self.next_token,
            }
        }
    }
}
impl ListLongTermPricingOutput {
    /// Creates a new builder-style object to manufacture [`ListLongTermPricingOutput`](crate::output::ListLongTermPricingOutput)
    pub fn builder() -> crate::output::list_long_term_pricing_output::Builder {
        crate::output::list_long_term_pricing_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListJobsOutput {
    /// <p>Each <code>JobListEntry</code> object contains a job's state, a job's ID, and a value
    /// that indicates whether the job is a job part, in the case of export jobs. </p>
    pub job_list_entries: std::option::Option<std::vec::Vec<crate::model::JobListEntry>>,
    /// <p>HTTP requests are stateless. If you use this automatically generated
    /// <code>NextToken</code> value in your next <code>ListJobs</code> call, your returned
    /// <code>JobListEntry</code> objects will start from this point in the array.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListJobsOutput {
    /// <p>Each <code>JobListEntry</code> object contains a job's state, a job's ID, and a value
    /// that indicates whether the job is a job part, in the case of export jobs. </p>
    pub fn job_list_entries(&self) -> std::option::Option<&[crate::model::JobListEntry]> {
        self.job_list_entries.as_deref()
    }
    /// <p>HTTP requests are stateless. If you use this automatically generated
    /// <code>NextToken</code> value in your next <code>ListJobs</code> call, your returned
    /// <code>JobListEntry</code> objects will start from this point in the array.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListJobsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListJobsOutput");
        formatter.field("job_list_entries", &self.job_list_entries);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListJobsOutput`](crate::output::ListJobsOutput)
pub mod list_jobs_output {
    /// A builder for [`ListJobsOutput`](crate::output::ListJobsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) job_list_entries: std::option::Option<std::vec::Vec<crate::model::JobListEntry>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `job_list_entries`.
        ///
        /// To override the contents of this collection use [`set_job_list_entries`](Self::set_job_list_entries).
        ///
        /// <p>Each <code>JobListEntry</code> object contains a job's state, a job's ID, and a value
        /// that indicates whether the job is a job part, in the case of export jobs. </p>
        pub fn job_list_entries(mut self, input: impl Into<crate::model::JobListEntry>) -> Self {
            let mut v = self.job_list_entries.unwrap_or_default();
            v.push(input.into());
            self.job_list_entries = Some(v);
            self
        }
        /// <p>Each <code>JobListEntry</code> object contains a job's state, a job's ID, and a value
        /// that indicates whether the job is a job part, in the case of export jobs. </p>
        pub fn set_job_list_entries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::JobListEntry>>,
        ) -> Self {
            self.job_list_entries = input;
            self
        }
        /// <p>HTTP requests are stateless. If you use this automatically generated
        /// <code>NextToken</code> value in your next <code>ListJobs</code> call, your returned
        /// <code>JobListEntry</code> objects will start from this point in the array.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>HTTP requests are stateless. If you use this automatically generated
        /// <code>NextToken</code> value in your next <code>ListJobs</code> call, your returned
        /// <code>JobListEntry</code> objects will start from this point in the array.</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 [`ListJobsOutput`](crate::output::ListJobsOutput)
        pub fn build(self) -> crate::output::ListJobsOutput {
            crate::output::ListJobsOutput {
                job_list_entries: self.job_list_entries,
                next_token: self.next_token,
            }
        }
    }
}
impl ListJobsOutput {
    /// Creates a new builder-style object to manufacture [`ListJobsOutput`](crate::output::ListJobsOutput)
    pub fn builder() -> crate::output::list_jobs_output::Builder {
        crate::output::list_jobs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListCompatibleImagesOutput {
    /// <p>A JSON-formatted object that describes a compatible AMI, including the ID and name for
    /// a Snow device AMI.</p>
    pub compatible_images: std::option::Option<std::vec::Vec<crate::model::CompatibleImage>>,
    /// <p>Because HTTP requests are stateless, this is the starting point for your next list of
    /// returned images.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListCompatibleImagesOutput {
    /// <p>A JSON-formatted object that describes a compatible AMI, including the ID and name for
    /// a Snow device AMI.</p>
    pub fn compatible_images(&self) -> std::option::Option<&[crate::model::CompatibleImage]> {
        self.compatible_images.as_deref()
    }
    /// <p>Because HTTP requests are stateless, this is the starting point for your next list of
    /// returned images.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListCompatibleImagesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListCompatibleImagesOutput");
        formatter.field("compatible_images", &self.compatible_images);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListCompatibleImagesOutput`](crate::output::ListCompatibleImagesOutput)
pub mod list_compatible_images_output {
    /// A builder for [`ListCompatibleImagesOutput`](crate::output::ListCompatibleImagesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) compatible_images:
            std::option::Option<std::vec::Vec<crate::model::CompatibleImage>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `compatible_images`.
        ///
        /// To override the contents of this collection use [`set_compatible_images`](Self::set_compatible_images).
        ///
        /// <p>A JSON-formatted object that describes a compatible AMI, including the ID and name for
        /// a Snow device AMI.</p>
        pub fn compatible_images(
            mut self,
            input: impl Into<crate::model::CompatibleImage>,
        ) -> Self {
            let mut v = self.compatible_images.unwrap_or_default();
            v.push(input.into());
            self.compatible_images = Some(v);
            self
        }
        /// <p>A JSON-formatted object that describes a compatible AMI, including the ID and name for
        /// a Snow device AMI.</p>
        pub fn set_compatible_images(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::CompatibleImage>>,
        ) -> Self {
            self.compatible_images = input;
            self
        }
        /// <p>Because HTTP requests are stateless, this is the starting point for your next list of
        /// returned images.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>Because HTTP requests are stateless, this is the starting point for your next list of
        /// returned images.</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 [`ListCompatibleImagesOutput`](crate::output::ListCompatibleImagesOutput)
        pub fn build(self) -> crate::output::ListCompatibleImagesOutput {
            crate::output::ListCompatibleImagesOutput {
                compatible_images: self.compatible_images,
                next_token: self.next_token,
            }
        }
    }
}
impl ListCompatibleImagesOutput {
    /// Creates a new builder-style object to manufacture [`ListCompatibleImagesOutput`](crate::output::ListCompatibleImagesOutput)
    pub fn builder() -> crate::output::list_compatible_images_output::Builder {
        crate::output::list_compatible_images_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListClustersOutput {
    /// <p>Each <code>ClusterListEntry</code> object contains a cluster's state, a cluster's ID,
    /// and other important status information.</p>
    pub cluster_list_entries: std::option::Option<std::vec::Vec<crate::model::ClusterListEntry>>,
    /// <p>HTTP requests are stateless. If you use the automatically generated
    /// <code>NextToken</code> value in your next <code>ClusterListEntry</code> call, your list of
    /// returned clusters will start from this point in the array.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListClustersOutput {
    /// <p>Each <code>ClusterListEntry</code> object contains a cluster's state, a cluster's ID,
    /// and other important status information.</p>
    pub fn cluster_list_entries(&self) -> std::option::Option<&[crate::model::ClusterListEntry]> {
        self.cluster_list_entries.as_deref()
    }
    /// <p>HTTP requests are stateless. If you use the automatically generated
    /// <code>NextToken</code> value in your next <code>ClusterListEntry</code> call, your list of
    /// returned clusters will start from this point in the array.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListClustersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListClustersOutput");
        formatter.field("cluster_list_entries", &self.cluster_list_entries);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListClustersOutput`](crate::output::ListClustersOutput)
pub mod list_clusters_output {
    /// A builder for [`ListClustersOutput`](crate::output::ListClustersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster_list_entries:
            std::option::Option<std::vec::Vec<crate::model::ClusterListEntry>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `cluster_list_entries`.
        ///
        /// To override the contents of this collection use [`set_cluster_list_entries`](Self::set_cluster_list_entries).
        ///
        /// <p>Each <code>ClusterListEntry</code> object contains a cluster's state, a cluster's ID,
        /// and other important status information.</p>
        pub fn cluster_list_entries(
            mut self,
            input: impl Into<crate::model::ClusterListEntry>,
        ) -> Self {
            let mut v = self.cluster_list_entries.unwrap_or_default();
            v.push(input.into());
            self.cluster_list_entries = Some(v);
            self
        }
        /// <p>Each <code>ClusterListEntry</code> object contains a cluster's state, a cluster's ID,
        /// and other important status information.</p>
        pub fn set_cluster_list_entries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ClusterListEntry>>,
        ) -> Self {
            self.cluster_list_entries = input;
            self
        }
        /// <p>HTTP requests are stateless. If you use the automatically generated
        /// <code>NextToken</code> value in your next <code>ClusterListEntry</code> call, your list of
        /// returned clusters will start from this point in the array.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>HTTP requests are stateless. If you use the automatically generated
        /// <code>NextToken</code> value in your next <code>ClusterListEntry</code> call, your list of
        /// returned clusters will start from this point in the array.</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 [`ListClustersOutput`](crate::output::ListClustersOutput)
        pub fn build(self) -> crate::output::ListClustersOutput {
            crate::output::ListClustersOutput {
                cluster_list_entries: self.cluster_list_entries,
                next_token: self.next_token,
            }
        }
    }
}
impl ListClustersOutput {
    /// Creates a new builder-style object to manufacture [`ListClustersOutput`](crate::output::ListClustersOutput)
    pub fn builder() -> crate::output::list_clusters_output::Builder {
        crate::output::list_clusters_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListClusterJobsOutput {
    /// <p>Each <code>JobListEntry</code> object contains a job's state, a job's ID, and a value
    /// that indicates whether the job is a job part, in the case of export jobs. </p>
    pub job_list_entries: std::option::Option<std::vec::Vec<crate::model::JobListEntry>>,
    /// <p>HTTP requests are stateless. If you use the automatically generated
    /// <code>NextToken</code> value in your next <code>ListClusterJobsResult</code> call, your list
    /// of returned jobs will start from this point in the array.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListClusterJobsOutput {
    /// <p>Each <code>JobListEntry</code> object contains a job's state, a job's ID, and a value
    /// that indicates whether the job is a job part, in the case of export jobs. </p>
    pub fn job_list_entries(&self) -> std::option::Option<&[crate::model::JobListEntry]> {
        self.job_list_entries.as_deref()
    }
    /// <p>HTTP requests are stateless. If you use the automatically generated
    /// <code>NextToken</code> value in your next <code>ListClusterJobsResult</code> call, your list
    /// of returned jobs will start from this point in the array.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListClusterJobsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListClusterJobsOutput");
        formatter.field("job_list_entries", &self.job_list_entries);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListClusterJobsOutput`](crate::output::ListClusterJobsOutput)
pub mod list_cluster_jobs_output {
    /// A builder for [`ListClusterJobsOutput`](crate::output::ListClusterJobsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) job_list_entries: std::option::Option<std::vec::Vec<crate::model::JobListEntry>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `job_list_entries`.
        ///
        /// To override the contents of this collection use [`set_job_list_entries`](Self::set_job_list_entries).
        ///
        /// <p>Each <code>JobListEntry</code> object contains a job's state, a job's ID, and a value
        /// that indicates whether the job is a job part, in the case of export jobs. </p>
        pub fn job_list_entries(mut self, input: impl Into<crate::model::JobListEntry>) -> Self {
            let mut v = self.job_list_entries.unwrap_or_default();
            v.push(input.into());
            self.job_list_entries = Some(v);
            self
        }
        /// <p>Each <code>JobListEntry</code> object contains a job's state, a job's ID, and a value
        /// that indicates whether the job is a job part, in the case of export jobs. </p>
        pub fn set_job_list_entries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::JobListEntry>>,
        ) -> Self {
            self.job_list_entries = input;
            self
        }
        /// <p>HTTP requests are stateless. If you use the automatically generated
        /// <code>NextToken</code> value in your next <code>ListClusterJobsResult</code> call, your list
        /// of returned jobs will start from this point in the array.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>HTTP requests are stateless. If you use the automatically generated
        /// <code>NextToken</code> value in your next <code>ListClusterJobsResult</code> call, your list
        /// of returned jobs will start from this point in the array.</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 [`ListClusterJobsOutput`](crate::output::ListClusterJobsOutput)
        pub fn build(self) -> crate::output::ListClusterJobsOutput {
            crate::output::ListClusterJobsOutput {
                job_list_entries: self.job_list_entries,
                next_token: self.next_token,
            }
        }
    }
}
impl ListClusterJobsOutput {
    /// Creates a new builder-style object to manufacture [`ListClusterJobsOutput`](crate::output::ListClusterJobsOutput)
    pub fn builder() -> crate::output::list_cluster_jobs_output::Builder {
        crate::output::list_cluster_jobs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetSoftwareUpdatesOutput {
    /// <p>The Amazon S3 presigned URL for the update file associated with the specified
    /// <code>JobId</code> value. The software update will be available for 2 days after this request is made.
    /// To access an update after the 2 days have passed, you'll have to make another call to <code>GetSoftwareUpdates</code>.</p>
    pub updates_uri: std::option::Option<std::string::String>,
}
impl GetSoftwareUpdatesOutput {
    /// <p>The Amazon S3 presigned URL for the update file associated with the specified
    /// <code>JobId</code> value. The software update will be available for 2 days after this request is made.
    /// To access an update after the 2 days have passed, you'll have to make another call to <code>GetSoftwareUpdates</code>.</p>
    pub fn updates_uri(&self) -> std::option::Option<&str> {
        self.updates_uri.as_deref()
    }
}
impl std::fmt::Debug for GetSoftwareUpdatesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetSoftwareUpdatesOutput");
        formatter.field("updates_uri", &self.updates_uri);
        formatter.finish()
    }
}
/// See [`GetSoftwareUpdatesOutput`](crate::output::GetSoftwareUpdatesOutput)
pub mod get_software_updates_output {
    /// A builder for [`GetSoftwareUpdatesOutput`](crate::output::GetSoftwareUpdatesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) updates_uri: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon S3 presigned URL for the update file associated with the specified
        /// <code>JobId</code> value. The software update will be available for 2 days after this request is made.
        /// To access an update after the 2 days have passed, you'll have to make another call to <code>GetSoftwareUpdates</code>.</p>
        pub fn updates_uri(mut self, input: impl Into<std::string::String>) -> Self {
            self.updates_uri = Some(input.into());
            self
        }
        /// <p>The Amazon S3 presigned URL for the update file associated with the specified
        /// <code>JobId</code> value. The software update will be available for 2 days after this request is made.
        /// To access an update after the 2 days have passed, you'll have to make another call to <code>GetSoftwareUpdates</code>.</p>
        pub fn set_updates_uri(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.updates_uri = input;
            self
        }
        /// Consumes the builder and constructs a [`GetSoftwareUpdatesOutput`](crate::output::GetSoftwareUpdatesOutput)
        pub fn build(self) -> crate::output::GetSoftwareUpdatesOutput {
            crate::output::GetSoftwareUpdatesOutput {
                updates_uri: self.updates_uri,
            }
        }
    }
}
impl GetSoftwareUpdatesOutput {
    /// Creates a new builder-style object to manufacture [`GetSoftwareUpdatesOutput`](crate::output::GetSoftwareUpdatesOutput)
    pub fn builder() -> crate::output::get_software_updates_output::Builder {
        crate::output::get_software_updates_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetSnowballUsageOutput {
    /// <p>The service limit for number of Snow devices this account can have at once. The default
    /// service limit is 1 (one).</p>
    pub snowball_limit: std::option::Option<i32>,
    /// <p>The number of Snow devices that this account is currently using.</p>
    pub snowballs_in_use: std::option::Option<i32>,
}
impl GetSnowballUsageOutput {
    /// <p>The service limit for number of Snow devices this account can have at once. The default
    /// service limit is 1 (one).</p>
    pub fn snowball_limit(&self) -> std::option::Option<i32> {
        self.snowball_limit
    }
    /// <p>The number of Snow devices that this account is currently using.</p>
    pub fn snowballs_in_use(&self) -> std::option::Option<i32> {
        self.snowballs_in_use
    }
}
impl std::fmt::Debug for GetSnowballUsageOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetSnowballUsageOutput");
        formatter.field("snowball_limit", &self.snowball_limit);
        formatter.field("snowballs_in_use", &self.snowballs_in_use);
        formatter.finish()
    }
}
/// See [`GetSnowballUsageOutput`](crate::output::GetSnowballUsageOutput)
pub mod get_snowball_usage_output {
    /// A builder for [`GetSnowballUsageOutput`](crate::output::GetSnowballUsageOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) snowball_limit: std::option::Option<i32>,
        pub(crate) snowballs_in_use: std::option::Option<i32>,
    }
    impl Builder {
        /// <p>The service limit for number of Snow devices this account can have at once. The default
        /// service limit is 1 (one).</p>
        pub fn snowball_limit(mut self, input: i32) -> Self {
            self.snowball_limit = Some(input);
            self
        }
        /// <p>The service limit for number of Snow devices this account can have at once. The default
        /// service limit is 1 (one).</p>
        pub fn set_snowball_limit(mut self, input: std::option::Option<i32>) -> Self {
            self.snowball_limit = input;
            self
        }
        /// <p>The number of Snow devices that this account is currently using.</p>
        pub fn snowballs_in_use(mut self, input: i32) -> Self {
            self.snowballs_in_use = Some(input);
            self
        }
        /// <p>The number of Snow devices that this account is currently using.</p>
        pub fn set_snowballs_in_use(mut self, input: std::option::Option<i32>) -> Self {
            self.snowballs_in_use = input;
            self
        }
        /// Consumes the builder and constructs a [`GetSnowballUsageOutput`](crate::output::GetSnowballUsageOutput)
        pub fn build(self) -> crate::output::GetSnowballUsageOutput {
            crate::output::GetSnowballUsageOutput {
                snowball_limit: self.snowball_limit,
                snowballs_in_use: self.snowballs_in_use,
            }
        }
    }
}
impl GetSnowballUsageOutput {
    /// Creates a new builder-style object to manufacture [`GetSnowballUsageOutput`](crate::output::GetSnowballUsageOutput)
    pub fn builder() -> crate::output::get_snowball_usage_output::Builder {
        crate::output::get_snowball_usage_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetJobUnlockCodeOutput {
    /// <p>The <code>UnlockCode</code> value for the specified job. The <code>UnlockCode</code>
    /// value can be accessed for up to 360 days after the job has been created.</p>
    pub unlock_code: std::option::Option<std::string::String>,
}
impl GetJobUnlockCodeOutput {
    /// <p>The <code>UnlockCode</code> value for the specified job. The <code>UnlockCode</code>
    /// value can be accessed for up to 360 days after the job has been created.</p>
    pub fn unlock_code(&self) -> std::option::Option<&str> {
        self.unlock_code.as_deref()
    }
}
impl std::fmt::Debug for GetJobUnlockCodeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetJobUnlockCodeOutput");
        formatter.field("unlock_code", &self.unlock_code);
        formatter.finish()
    }
}
/// See [`GetJobUnlockCodeOutput`](crate::output::GetJobUnlockCodeOutput)
pub mod get_job_unlock_code_output {
    /// A builder for [`GetJobUnlockCodeOutput`](crate::output::GetJobUnlockCodeOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) unlock_code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The <code>UnlockCode</code> value for the specified job. The <code>UnlockCode</code>
        /// value can be accessed for up to 360 days after the job has been created.</p>
        pub fn unlock_code(mut self, input: impl Into<std::string::String>) -> Self {
            self.unlock_code = Some(input.into());
            self
        }
        /// <p>The <code>UnlockCode</code> value for the specified job. The <code>UnlockCode</code>
        /// value can be accessed for up to 360 days after the job has been created.</p>
        pub fn set_unlock_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.unlock_code = input;
            self
        }
        /// Consumes the builder and constructs a [`GetJobUnlockCodeOutput`](crate::output::GetJobUnlockCodeOutput)
        pub fn build(self) -> crate::output::GetJobUnlockCodeOutput {
            crate::output::GetJobUnlockCodeOutput {
                unlock_code: self.unlock_code,
            }
        }
    }
}
impl GetJobUnlockCodeOutput {
    /// Creates a new builder-style object to manufacture [`GetJobUnlockCodeOutput`](crate::output::GetJobUnlockCodeOutput)
    pub fn builder() -> crate::output::get_job_unlock_code_output::Builder {
        crate::output::get_job_unlock_code_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetJobManifestOutput {
    /// <p>The Amazon S3 presigned URL for the manifest file associated with the specified
    /// <code>JobId</code> value.</p>
    pub manifest_uri: std::option::Option<std::string::String>,
}
impl GetJobManifestOutput {
    /// <p>The Amazon S3 presigned URL for the manifest file associated with the specified
    /// <code>JobId</code> value.</p>
    pub fn manifest_uri(&self) -> std::option::Option<&str> {
        self.manifest_uri.as_deref()
    }
}
impl std::fmt::Debug for GetJobManifestOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetJobManifestOutput");
        formatter.field("manifest_uri", &self.manifest_uri);
        formatter.finish()
    }
}
/// See [`GetJobManifestOutput`](crate::output::GetJobManifestOutput)
pub mod get_job_manifest_output {
    /// A builder for [`GetJobManifestOutput`](crate::output::GetJobManifestOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) manifest_uri: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon S3 presigned URL for the manifest file associated with the specified
        /// <code>JobId</code> value.</p>
        pub fn manifest_uri(mut self, input: impl Into<std::string::String>) -> Self {
            self.manifest_uri = Some(input.into());
            self
        }
        /// <p>The Amazon S3 presigned URL for the manifest file associated with the specified
        /// <code>JobId</code> value.</p>
        pub fn set_manifest_uri(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.manifest_uri = input;
            self
        }
        /// Consumes the builder and constructs a [`GetJobManifestOutput`](crate::output::GetJobManifestOutput)
        pub fn build(self) -> crate::output::GetJobManifestOutput {
            crate::output::GetJobManifestOutput {
                manifest_uri: self.manifest_uri,
            }
        }
    }
}
impl GetJobManifestOutput {
    /// Creates a new builder-style object to manufacture [`GetJobManifestOutput`](crate::output::GetJobManifestOutput)
    pub fn builder() -> crate::output::get_job_manifest_output::Builder {
        crate::output::get_job_manifest_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeReturnShippingLabelOutput {
    /// <p>The status information of the task on a Snow device that is being returned to AWS.</p>
    pub status: std::option::Option<crate::model::ShippingLabelStatus>,
    /// <p>The expiration date of the current return shipping label.</p>
    pub expiration_date: std::option::Option<aws_smithy_types::Instant>,
}
impl DescribeReturnShippingLabelOutput {
    /// <p>The status information of the task on a Snow device that is being returned to AWS.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::ShippingLabelStatus> {
        self.status.as_ref()
    }
    /// <p>The expiration date of the current return shipping label.</p>
    pub fn expiration_date(&self) -> std::option::Option<&aws_smithy_types::Instant> {
        self.expiration_date.as_ref()
    }
}
impl std::fmt::Debug for DescribeReturnShippingLabelOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeReturnShippingLabelOutput");
        formatter.field("status", &self.status);
        formatter.field("expiration_date", &self.expiration_date);
        formatter.finish()
    }
}
/// See [`DescribeReturnShippingLabelOutput`](crate::output::DescribeReturnShippingLabelOutput)
pub mod describe_return_shipping_label_output {
    /// A builder for [`DescribeReturnShippingLabelOutput`](crate::output::DescribeReturnShippingLabelOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::ShippingLabelStatus>,
        pub(crate) expiration_date: std::option::Option<aws_smithy_types::Instant>,
    }
    impl Builder {
        /// <p>The status information of the task on a Snow device that is being returned to AWS.</p>
        pub fn status(mut self, input: crate::model::ShippingLabelStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>The status information of the task on a Snow device that is being returned to AWS.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::ShippingLabelStatus>,
        ) -> Self {
            self.status = input;
            self
        }
        /// <p>The expiration date of the current return shipping label.</p>
        pub fn expiration_date(mut self, input: aws_smithy_types::Instant) -> Self {
            self.expiration_date = Some(input);
            self
        }
        /// <p>The expiration date of the current return shipping label.</p>
        pub fn set_expiration_date(
            mut self,
            input: std::option::Option<aws_smithy_types::Instant>,
        ) -> Self {
            self.expiration_date = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeReturnShippingLabelOutput`](crate::output::DescribeReturnShippingLabelOutput)
        pub fn build(self) -> crate::output::DescribeReturnShippingLabelOutput {
            crate::output::DescribeReturnShippingLabelOutput {
                status: self.status,
                expiration_date: self.expiration_date,
            }
        }
    }
}
impl DescribeReturnShippingLabelOutput {
    /// Creates a new builder-style object to manufacture [`DescribeReturnShippingLabelOutput`](crate::output::DescribeReturnShippingLabelOutput)
    pub fn builder() -> crate::output::describe_return_shipping_label_output::Builder {
        crate::output::describe_return_shipping_label_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeJobOutput {
    /// <p>Information about a specific job, including shipping information, job status, and other
    /// important metadata.</p>
    pub job_metadata: std::option::Option<crate::model::JobMetadata>,
    /// <p>Information about a specific job part (in the case of an export job), including
    /// shipping information, job status, and other important metadata.</p>
    pub sub_job_metadata: std::option::Option<std::vec::Vec<crate::model::JobMetadata>>,
}
impl DescribeJobOutput {
    /// <p>Information about a specific job, including shipping information, job status, and other
    /// important metadata.</p>
    pub fn job_metadata(&self) -> std::option::Option<&crate::model::JobMetadata> {
        self.job_metadata.as_ref()
    }
    /// <p>Information about a specific job part (in the case of an export job), including
    /// shipping information, job status, and other important metadata.</p>
    pub fn sub_job_metadata(&self) -> std::option::Option<&[crate::model::JobMetadata]> {
        self.sub_job_metadata.as_deref()
    }
}
impl std::fmt::Debug for DescribeJobOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeJobOutput");
        formatter.field("job_metadata", &self.job_metadata);
        formatter.field("sub_job_metadata", &self.sub_job_metadata);
        formatter.finish()
    }
}
/// See [`DescribeJobOutput`](crate::output::DescribeJobOutput)
pub mod describe_job_output {
    /// A builder for [`DescribeJobOutput`](crate::output::DescribeJobOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) job_metadata: std::option::Option<crate::model::JobMetadata>,
        pub(crate) sub_job_metadata: std::option::Option<std::vec::Vec<crate::model::JobMetadata>>,
    }
    impl Builder {
        /// <p>Information about a specific job, including shipping information, job status, and other
        /// important metadata.</p>
        pub fn job_metadata(mut self, input: crate::model::JobMetadata) -> Self {
            self.job_metadata = Some(input);
            self
        }
        /// <p>Information about a specific job, including shipping information, job status, and other
        /// important metadata.</p>
        pub fn set_job_metadata(
            mut self,
            input: std::option::Option<crate::model::JobMetadata>,
        ) -> Self {
            self.job_metadata = input;
            self
        }
        /// Appends an item to `sub_job_metadata`.
        ///
        /// To override the contents of this collection use [`set_sub_job_metadata`](Self::set_sub_job_metadata).
        ///
        /// <p>Information about a specific job part (in the case of an export job), including
        /// shipping information, job status, and other important metadata.</p>
        pub fn sub_job_metadata(mut self, input: impl Into<crate::model::JobMetadata>) -> Self {
            let mut v = self.sub_job_metadata.unwrap_or_default();
            v.push(input.into());
            self.sub_job_metadata = Some(v);
            self
        }
        /// <p>Information about a specific job part (in the case of an export job), including
        /// shipping information, job status, and other important metadata.</p>
        pub fn set_sub_job_metadata(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::JobMetadata>>,
        ) -> Self {
            self.sub_job_metadata = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeJobOutput`](crate::output::DescribeJobOutput)
        pub fn build(self) -> crate::output::DescribeJobOutput {
            crate::output::DescribeJobOutput {
                job_metadata: self.job_metadata,
                sub_job_metadata: self.sub_job_metadata,
            }
        }
    }
}
impl DescribeJobOutput {
    /// Creates a new builder-style object to manufacture [`DescribeJobOutput`](crate::output::DescribeJobOutput)
    pub fn builder() -> crate::output::describe_job_output::Builder {
        crate::output::describe_job_output::Builder::default()
    }
}

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAddressesOutput {
    /// <p>The Snow device shipping addresses that were created for this account.</p>
    pub addresses: std::option::Option<std::vec::Vec<crate::model::Address>>,
    /// <p>HTTP requests are stateless. If you use the automatically generated
    /// <code>NextToken</code> value in your next <code>DescribeAddresses</code> call, your list of
    /// returned addresses will start from this point in the array.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeAddressesOutput {
    /// <p>The Snow device shipping addresses that were created for this account.</p>
    pub fn addresses(&self) -> std::option::Option<&[crate::model::Address]> {
        self.addresses.as_deref()
    }
    /// <p>HTTP requests are stateless. If you use the automatically generated
    /// <code>NextToken</code> value in your next <code>DescribeAddresses</code> call, your list of
    /// returned addresses will start from this point in the array.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeAddressesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAddressesOutput");
        formatter.field("addresses", &self.addresses);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeAddressesOutput`](crate::output::DescribeAddressesOutput)
pub mod describe_addresses_output {
    /// A builder for [`DescribeAddressesOutput`](crate::output::DescribeAddressesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) addresses: std::option::Option<std::vec::Vec<crate::model::Address>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `addresses`.
        ///
        /// To override the contents of this collection use [`set_addresses`](Self::set_addresses).
        ///
        /// <p>The Snow device shipping addresses that were created for this account.</p>
        pub fn addresses(mut self, input: impl Into<crate::model::Address>) -> Self {
            let mut v = self.addresses.unwrap_or_default();
            v.push(input.into());
            self.addresses = Some(v);
            self
        }
        /// <p>The Snow device shipping addresses that were created for this account.</p>
        pub fn set_addresses(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Address>>,
        ) -> Self {
            self.addresses = input;
            self
        }
        /// <p>HTTP requests are stateless. If you use the automatically generated
        /// <code>NextToken</code> value in your next <code>DescribeAddresses</code> call, your list of
        /// returned addresses will start from this point in the array.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>HTTP requests are stateless. If you use the automatically generated
        /// <code>NextToken</code> value in your next <code>DescribeAddresses</code> call, your list of
        /// returned addresses will start from this point in the array.</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 [`DescribeAddressesOutput`](crate::output::DescribeAddressesOutput)
        pub fn build(self) -> crate::output::DescribeAddressesOutput {
            crate::output::DescribeAddressesOutput {
                addresses: self.addresses,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeAddressesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAddressesOutput`](crate::output::DescribeAddressesOutput)
    pub fn builder() -> crate::output::describe_addresses_output::Builder {
        crate::output::describe_addresses_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAddressOutput {
    /// <p>The address that you want the Snow device(s) associated with a specific job to
    /// be shipped to.</p>
    pub address: std::option::Option<crate::model::Address>,
}
impl DescribeAddressOutput {
    /// <p>The address that you want the Snow device(s) associated with a specific job to
    /// be shipped to.</p>
    pub fn address(&self) -> std::option::Option<&crate::model::Address> {
        self.address.as_ref()
    }
}
impl std::fmt::Debug for DescribeAddressOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAddressOutput");
        formatter.field("address", &self.address);
        formatter.finish()
    }
}
/// See [`DescribeAddressOutput`](crate::output::DescribeAddressOutput)
pub mod describe_address_output {
    /// A builder for [`DescribeAddressOutput`](crate::output::DescribeAddressOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) address: std::option::Option<crate::model::Address>,
    }
    impl Builder {
        /// <p>The address that you want the Snow device(s) associated with a specific job to
        /// be shipped to.</p>
        pub fn address(mut self, input: crate::model::Address) -> Self {
            self.address = Some(input);
            self
        }
        /// <p>The address that you want the Snow device(s) associated with a specific job to
        /// be shipped to.</p>
        pub fn set_address(mut self, input: std::option::Option<crate::model::Address>) -> Self {
            self.address = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAddressOutput`](crate::output::DescribeAddressOutput)
        pub fn build(self) -> crate::output::DescribeAddressOutput {
            crate::output::DescribeAddressOutput {
                address: self.address,
            }
        }
    }
}
impl DescribeAddressOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAddressOutput`](crate::output::DescribeAddressOutput)
    pub fn builder() -> crate::output::describe_address_output::Builder {
        crate::output::describe_address_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateReturnShippingLabelOutput {
    /// <p>The status information of the task on a Snow device that is being returned to AWS.</p>
    pub status: std::option::Option<crate::model::ShippingLabelStatus>,
}
impl CreateReturnShippingLabelOutput {
    /// <p>The status information of the task on a Snow device that is being returned to AWS.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::ShippingLabelStatus> {
        self.status.as_ref()
    }
}
impl std::fmt::Debug for CreateReturnShippingLabelOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateReturnShippingLabelOutput");
        formatter.field("status", &self.status);
        formatter.finish()
    }
}
/// See [`CreateReturnShippingLabelOutput`](crate::output::CreateReturnShippingLabelOutput)
pub mod create_return_shipping_label_output {
    /// A builder for [`CreateReturnShippingLabelOutput`](crate::output::CreateReturnShippingLabelOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::ShippingLabelStatus>,
    }
    impl Builder {
        /// <p>The status information of the task on a Snow device that is being returned to AWS.</p>
        pub fn status(mut self, input: crate::model::ShippingLabelStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>The status information of the task on a Snow device that is being returned to AWS.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::ShippingLabelStatus>,
        ) -> Self {
            self.status = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateReturnShippingLabelOutput`](crate::output::CreateReturnShippingLabelOutput)
        pub fn build(self) -> crate::output::CreateReturnShippingLabelOutput {
            crate::output::CreateReturnShippingLabelOutput {
                status: self.status,
            }
        }
    }
}
impl CreateReturnShippingLabelOutput {
    /// Creates a new builder-style object to manufacture [`CreateReturnShippingLabelOutput`](crate::output::CreateReturnShippingLabelOutput)
    pub fn builder() -> crate::output::create_return_shipping_label_output::Builder {
        crate::output::create_return_shipping_label_output::Builder::default()
    }
}

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateJobOutput {
    /// <p>The automatically generated ID for a job, for example
    /// <code>JID123e4567-e89b-12d3-a456-426655440000</code>.</p>
    pub job_id: std::option::Option<std::string::String>,
}
impl CreateJobOutput {
    /// <p>The automatically generated ID for a job, for example
    /// <code>JID123e4567-e89b-12d3-a456-426655440000</code>.</p>
    pub fn job_id(&self) -> std::option::Option<&str> {
        self.job_id.as_deref()
    }
}
impl std::fmt::Debug for CreateJobOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateJobOutput");
        formatter.field("job_id", &self.job_id);
        formatter.finish()
    }
}
/// See [`CreateJobOutput`](crate::output::CreateJobOutput)
pub mod create_job_output {
    /// A builder for [`CreateJobOutput`](crate::output::CreateJobOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) job_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The automatically generated ID for a job, for example
        /// <code>JID123e4567-e89b-12d3-a456-426655440000</code>.</p>
        pub fn job_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.job_id = Some(input.into());
            self
        }
        /// <p>The automatically generated ID for a job, for example
        /// <code>JID123e4567-e89b-12d3-a456-426655440000</code>.</p>
        pub fn set_job_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.job_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateJobOutput`](crate::output::CreateJobOutput)
        pub fn build(self) -> crate::output::CreateJobOutput {
            crate::output::CreateJobOutput {
                job_id: self.job_id,
            }
        }
    }
}
impl CreateJobOutput {
    /// Creates a new builder-style object to manufacture [`CreateJobOutput`](crate::output::CreateJobOutput)
    pub fn builder() -> crate::output::create_job_output::Builder {
        crate::output::create_job_output::Builder::default()
    }
}

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateAddressOutput {
    /// <p>The automatically generated ID for a specific address. You'll use this ID when you
    /// create a job to specify which address you want the Snow device for that job shipped to.</p>
    pub address_id: std::option::Option<std::string::String>,
}
impl CreateAddressOutput {
    /// <p>The automatically generated ID for a specific address. You'll use this ID when you
    /// create a job to specify which address you want the Snow device for that job shipped to.</p>
    pub fn address_id(&self) -> std::option::Option<&str> {
        self.address_id.as_deref()
    }
}
impl std::fmt::Debug for CreateAddressOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateAddressOutput");
        formatter.field("address_id", &self.address_id);
        formatter.finish()
    }
}
/// See [`CreateAddressOutput`](crate::output::CreateAddressOutput)
pub mod create_address_output {
    /// A builder for [`CreateAddressOutput`](crate::output::CreateAddressOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) address_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The automatically generated ID for a specific address. You'll use this ID when you
        /// create a job to specify which address you want the Snow device for that job shipped to.</p>
        pub fn address_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.address_id = Some(input.into());
            self
        }
        /// <p>The automatically generated ID for a specific address. You'll use this ID when you
        /// create a job to specify which address you want the Snow device for that job shipped to.</p>
        pub fn set_address_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.address_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateAddressOutput`](crate::output::CreateAddressOutput)
        pub fn build(self) -> crate::output::CreateAddressOutput {
            crate::output::CreateAddressOutput {
                address_id: self.address_id,
            }
        }
    }
}
impl CreateAddressOutput {
    /// Creates a new builder-style object to manufacture [`CreateAddressOutput`](crate::output::CreateAddressOutput)
    pub fn builder() -> crate::output::create_address_output::Builder {
        crate::output::create_address_output::Builder::default()
    }
}

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

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