output.rs

// 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 {
    /// <p>Returned after a successful <code>UpdateVolume</code> API operation, describing the volume just updated.</p>
    pub volume: std::option::Option<crate::model::Volume>,
}
impl UpdateVolumeOutput {
    /// <p>Returned after a successful <code>UpdateVolume</code> API operation, describing the volume just updated.</p>
    pub fn volume(&self) -> std::option::Option<&crate::model::Volume> {
        self.volume.as_ref()
    }
}
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.field("volume", &self.volume);
        formatter.finish()
    }
}
/// See [`UpdateVolumeOutput`](crate::output::UpdateVolumeOutput)
pub mod update_volume_output {
    /// A builder for [`UpdateVolumeOutput`](crate::output::UpdateVolumeOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) volume: std::option::Option<crate::model::Volume>,
    }
    impl Builder {
        /// <p>Returned after a successful <code>UpdateVolume</code> API operation, describing the volume just updated.</p>
        pub fn volume(mut self, input: crate::model::Volume) -> Self {
            self.volume = Some(input);
            self
        }
        /// <p>Returned after a successful <code>UpdateVolume</code> API operation, describing the volume just updated.</p>
        pub fn set_volume(mut self, input: std::option::Option<crate::model::Volume>) -> Self {
            self.volume = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateVolumeOutput`](crate::output::UpdateVolumeOutput)
        pub fn build(self) -> crate::output::UpdateVolumeOutput {
            crate::output::UpdateVolumeOutput {
                volume: self.volume,
            }
        }
    }
}
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 UpdateStorageVirtualMachineOutput {
    /// <p>Describes the Amazon FSx for NetApp ONTAP storage virtual machine (SVM) configuraton.</p>
    pub storage_virtual_machine: std::option::Option<crate::model::StorageVirtualMachine>,
}
impl UpdateStorageVirtualMachineOutput {
    /// <p>Describes the Amazon FSx for NetApp ONTAP storage virtual machine (SVM) configuraton.</p>
    pub fn storage_virtual_machine(
        &self,
    ) -> std::option::Option<&crate::model::StorageVirtualMachine> {
        self.storage_virtual_machine.as_ref()
    }
}
impl std::fmt::Debug for UpdateStorageVirtualMachineOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateStorageVirtualMachineOutput");
        formatter.field("storage_virtual_machine", &self.storage_virtual_machine);
        formatter.finish()
    }
}
/// See [`UpdateStorageVirtualMachineOutput`](crate::output::UpdateStorageVirtualMachineOutput)
pub mod update_storage_virtual_machine_output {
    /// A builder for [`UpdateStorageVirtualMachineOutput`](crate::output::UpdateStorageVirtualMachineOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) storage_virtual_machine:
            std::option::Option<crate::model::StorageVirtualMachine>,
    }
    impl Builder {
        /// <p>Describes the Amazon FSx for NetApp ONTAP storage virtual machine (SVM) configuraton.</p>
        pub fn storage_virtual_machine(
            mut self,
            input: crate::model::StorageVirtualMachine,
        ) -> Self {
            self.storage_virtual_machine = Some(input);
            self
        }
        /// <p>Describes the Amazon FSx for NetApp ONTAP storage virtual machine (SVM) configuraton.</p>
        pub fn set_storage_virtual_machine(
            mut self,
            input: std::option::Option<crate::model::StorageVirtualMachine>,
        ) -> Self {
            self.storage_virtual_machine = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateStorageVirtualMachineOutput`](crate::output::UpdateStorageVirtualMachineOutput)
        pub fn build(self) -> crate::output::UpdateStorageVirtualMachineOutput {
            crate::output::UpdateStorageVirtualMachineOutput {
                storage_virtual_machine: self.storage_virtual_machine,
            }
        }
    }
}
impl UpdateStorageVirtualMachineOutput {
    /// Creates a new builder-style object to manufacture [`UpdateStorageVirtualMachineOutput`](crate::output::UpdateStorageVirtualMachineOutput)
    pub fn builder() -> crate::output::update_storage_virtual_machine_output::Builder {
        crate::output::update_storage_virtual_machine_output::Builder::default()
    }
}

/// <p>The response object for the <code>UpdateFileSystem</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateFileSystemOutput {
    /// <p>A description of the file system that was updated.</p>
    pub file_system: std::option::Option<crate::model::FileSystem>,
}
impl UpdateFileSystemOutput {
    /// <p>A description of the file system that was updated.</p>
    pub fn file_system(&self) -> std::option::Option<&crate::model::FileSystem> {
        self.file_system.as_ref()
    }
}
impl std::fmt::Debug for UpdateFileSystemOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateFileSystemOutput");
        formatter.field("file_system", &self.file_system);
        formatter.finish()
    }
}
/// See [`UpdateFileSystemOutput`](crate::output::UpdateFileSystemOutput)
pub mod update_file_system_output {
    /// A builder for [`UpdateFileSystemOutput`](crate::output::UpdateFileSystemOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) file_system: std::option::Option<crate::model::FileSystem>,
    }
    impl Builder {
        /// <p>A description of the file system that was updated.</p>
        pub fn file_system(mut self, input: crate::model::FileSystem) -> Self {
            self.file_system = Some(input);
            self
        }
        /// <p>A description of the file system that was updated.</p>
        pub fn set_file_system(
            mut self,
            input: std::option::Option<crate::model::FileSystem>,
        ) -> Self {
            self.file_system = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateFileSystemOutput`](crate::output::UpdateFileSystemOutput)
        pub fn build(self) -> crate::output::UpdateFileSystemOutput {
            crate::output::UpdateFileSystemOutput {
                file_system: self.file_system,
            }
        }
    }
}
impl UpdateFileSystemOutput {
    /// Creates a new builder-style object to manufacture [`UpdateFileSystemOutput`](crate::output::UpdateFileSystemOutput)
    pub fn builder() -> crate::output::update_file_system_output::Builder {
        crate::output::update_file_system_output::Builder::default()
    }
}

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

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

/// <p>The response object for <code>ListTagsForResource</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceOutput {
    /// <p>A list of tags on the resource.</p>
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>This is present if there are more tags than returned in the response (String). You
    /// can use the <code>NextToken</code> value in the later request to fetch the tags.
    /// </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListTagsForResourceOutput {
    /// <p>A list of tags on the resource.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
    /// <p>This is present if there are more tags than returned in the response (String). You
    /// can use the <code>NextToken</code> value in the later request to fetch the tags.
    /// </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListTagsForResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsForResourceOutput");
        formatter.field("tags", &self.tags);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
pub mod list_tags_for_resource_output {
    /// A builder for [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>A list of tags on the resource.</p>
        pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input.into());
            self.tags = Some(v);
            self
        }
        /// <p>A list of tags on the resource.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// <p>This is present if there are more tags than returned in the response (String). You
        /// can use the <code>NextToken</code> value in the later request to fetch the tags.
        /// </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>This is present if there are more tags than returned in the response (String). You
        /// can use the <code>NextToken</code> value in the later request to fetch the tags.
        /// </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 [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
        pub fn build(self) -> crate::output::ListTagsForResourceOutput {
            crate::output::ListTagsForResourceOutput {
                tags: self.tags,
                next_token: self.next_token,
            }
        }
    }
}
impl ListTagsForResourceOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
        crate::output::list_tags_for_resource_output::Builder::default()
    }
}

/// <p>The system generated response showing the DNS aliases that Amazon FSx is attempting to disassociate from the file system.
/// Use the  API operation to monitor the status of the aliases Amazon FSx is removing from the file system.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateFileSystemAliasesOutput {
    /// <p>An array of one or more DNS aliases that Amazon FSx is attempting to disassociate from the file system.</p>
    pub aliases: std::option::Option<std::vec::Vec<crate::model::Alias>>,
}
impl DisassociateFileSystemAliasesOutput {
    /// <p>An array of one or more DNS aliases that Amazon FSx is attempting to disassociate from the file system.</p>
    pub fn aliases(&self) -> std::option::Option<&[crate::model::Alias]> {
        self.aliases.as_deref()
    }
}
impl std::fmt::Debug for DisassociateFileSystemAliasesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DisassociateFileSystemAliasesOutput");
        formatter.field("aliases", &self.aliases);
        formatter.finish()
    }
}
/// See [`DisassociateFileSystemAliasesOutput`](crate::output::DisassociateFileSystemAliasesOutput)
pub mod disassociate_file_system_aliases_output {
    /// A builder for [`DisassociateFileSystemAliasesOutput`](crate::output::DisassociateFileSystemAliasesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aliases: std::option::Option<std::vec::Vec<crate::model::Alias>>,
    }
    impl Builder {
        /// Appends an item to `aliases`.
        ///
        /// To override the contents of this collection use [`set_aliases`](Self::set_aliases).
        ///
        /// <p>An array of one or more DNS aliases that Amazon FSx is attempting to disassociate from the file system.</p>
        pub fn aliases(mut self, input: impl Into<crate::model::Alias>) -> Self {
            let mut v = self.aliases.unwrap_or_default();
            v.push(input.into());
            self.aliases = Some(v);
            self
        }
        /// <p>An array of one or more DNS aliases that Amazon FSx is attempting to disassociate from the file system.</p>
        pub fn set_aliases(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Alias>>,
        ) -> Self {
            self.aliases = input;
            self
        }
        /// Consumes the builder and constructs a [`DisassociateFileSystemAliasesOutput`](crate::output::DisassociateFileSystemAliasesOutput)
        pub fn build(self) -> crate::output::DisassociateFileSystemAliasesOutput {
            crate::output::DisassociateFileSystemAliasesOutput {
                aliases: self.aliases,
            }
        }
    }
}
impl DisassociateFileSystemAliasesOutput {
    /// Creates a new builder-style object to manufacture [`DisassociateFileSystemAliasesOutput`](crate::output::DisassociateFileSystemAliasesOutput)
    pub fn builder() -> crate::output::disassociate_file_system_aliases_output::Builder {
        crate::output::disassociate_file_system_aliases_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeVolumesOutput {
    /// <p>Returned after a successful <code>DescribeVolumes</code> operation, describing each volume.</p>
    pub volumes: std::option::Option<std::vec::Vec<crate::model::Volume>>,
    /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
    /// present, this token indicates from what point you can continue processing the request, where
    /// the previous <code>NextToken</code> value left off.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeVolumesOutput {
    /// <p>Returned after a successful <code>DescribeVolumes</code> operation, describing each volume.</p>
    pub fn volumes(&self) -> std::option::Option<&[crate::model::Volume]> {
        self.volumes.as_deref()
    }
    /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
    /// present, this token indicates from what point you can continue processing the request, where
    /// the previous <code>NextToken</code> value left off.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.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.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeVolumesOutput`](crate::output::DescribeVolumesOutput)
pub mod describe_volumes_output {
    /// A builder for [`DescribeVolumesOutput`](crate::output::DescribeVolumesOutput)
    #[non_exhaustive]
    #[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>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `volumes`.
        ///
        /// To override the contents of this collection use [`set_volumes`](Self::set_volumes).
        ///
        /// <p>Returned after a successful <code>DescribeVolumes</code> operation, describing each volume.</p>
        pub fn volumes(mut self, input: impl Into<crate::model::Volume>) -> Self {
            let mut v = self.volumes.unwrap_or_default();
            v.push(input.into());
            self.volumes = Some(v);
            self
        }
        /// <p>Returned after a successful <code>DescribeVolumes</code> operation, describing each volume.</p>
        pub fn set_volumes(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Volume>>,
        ) -> Self {
            self.volumes = input;
            self
        }
        /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
        /// present, this token indicates from what point you can continue processing the request, where
        /// the previous <code>NextToken</code> value left off.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
        /// present, this token indicates from what point you can continue processing the request, where
        /// the previous <code>NextToken</code> value left off.</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 [`DescribeVolumesOutput`](crate::output::DescribeVolumesOutput)
        pub fn build(self) -> crate::output::DescribeVolumesOutput {
            crate::output::DescribeVolumesOutput {
                volumes: self.volumes,
                next_token: self.next_token,
            }
        }
    }
}
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()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeStorageVirtualMachinesOutput {
    /// <p>Returned after a successful <code>DescribeStorageVirtualMachines</code> operation, describing each SVM.</p>
    pub storage_virtual_machines:
        std::option::Option<std::vec::Vec<crate::model::StorageVirtualMachine>>,
    /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
    /// present, this token indicates from what point you can continue processing the request, where
    /// the previous <code>NextToken</code> value left off.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeStorageVirtualMachinesOutput {
    /// <p>Returned after a successful <code>DescribeStorageVirtualMachines</code> operation, describing each SVM.</p>
    pub fn storage_virtual_machines(
        &self,
    ) -> std::option::Option<&[crate::model::StorageVirtualMachine]> {
        self.storage_virtual_machines.as_deref()
    }
    /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
    /// present, this token indicates from what point you can continue processing the request, where
    /// the previous <code>NextToken</code> value left off.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeStorageVirtualMachinesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeStorageVirtualMachinesOutput");
        formatter.field("storage_virtual_machines", &self.storage_virtual_machines);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeStorageVirtualMachinesOutput`](crate::output::DescribeStorageVirtualMachinesOutput)
pub mod describe_storage_virtual_machines_output {
    /// A builder for [`DescribeStorageVirtualMachinesOutput`](crate::output::DescribeStorageVirtualMachinesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) storage_virtual_machines:
            std::option::Option<std::vec::Vec<crate::model::StorageVirtualMachine>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `storage_virtual_machines`.
        ///
        /// To override the contents of this collection use [`set_storage_virtual_machines`](Self::set_storage_virtual_machines).
        ///
        /// <p>Returned after a successful <code>DescribeStorageVirtualMachines</code> operation, describing each SVM.</p>
        pub fn storage_virtual_machines(
            mut self,
            input: impl Into<crate::model::StorageVirtualMachine>,
        ) -> Self {
            let mut v = self.storage_virtual_machines.unwrap_or_default();
            v.push(input.into());
            self.storage_virtual_machines = Some(v);
            self
        }
        /// <p>Returned after a successful <code>DescribeStorageVirtualMachines</code> operation, describing each SVM.</p>
        pub fn set_storage_virtual_machines(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::StorageVirtualMachine>>,
        ) -> Self {
            self.storage_virtual_machines = input;
            self
        }
        /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
        /// present, this token indicates from what point you can continue processing the request, where
        /// the previous <code>NextToken</code> value left off.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
        /// present, this token indicates from what point you can continue processing the request, where
        /// the previous <code>NextToken</code> value left off.</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 [`DescribeStorageVirtualMachinesOutput`](crate::output::DescribeStorageVirtualMachinesOutput)
        pub fn build(self) -> crate::output::DescribeStorageVirtualMachinesOutput {
            crate::output::DescribeStorageVirtualMachinesOutput {
                storage_virtual_machines: self.storage_virtual_machines,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeStorageVirtualMachinesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeStorageVirtualMachinesOutput`](crate::output::DescribeStorageVirtualMachinesOutput)
    pub fn builder() -> crate::output::describe_storage_virtual_machines_output::Builder {
        crate::output::describe_storage_virtual_machines_output::Builder::default()
    }
}

/// <p>The response object for <code>DescribeFileSystems</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeFileSystemsOutput {
    /// <p>An array of file system descriptions.</p>
    pub file_systems: std::option::Option<std::vec::Vec<crate::model::FileSystem>>,
    /// <p>Present if there are more file systems than returned in the response (String). You
    /// can use the <code>NextToken</code> value in the later request to fetch the
    /// descriptions. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeFileSystemsOutput {
    /// <p>An array of file system descriptions.</p>
    pub fn file_systems(&self) -> std::option::Option<&[crate::model::FileSystem]> {
        self.file_systems.as_deref()
    }
    /// <p>Present if there are more file systems than returned in the response (String). You
    /// can use the <code>NextToken</code> value in the later request to fetch the
    /// descriptions. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeFileSystemsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeFileSystemsOutput");
        formatter.field("file_systems", &self.file_systems);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeFileSystemsOutput`](crate::output::DescribeFileSystemsOutput)
pub mod describe_file_systems_output {
    /// A builder for [`DescribeFileSystemsOutput`](crate::output::DescribeFileSystemsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) file_systems: std::option::Option<std::vec::Vec<crate::model::FileSystem>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `file_systems`.
        ///
        /// To override the contents of this collection use [`set_file_systems`](Self::set_file_systems).
        ///
        /// <p>An array of file system descriptions.</p>
        pub fn file_systems(mut self, input: impl Into<crate::model::FileSystem>) -> Self {
            let mut v = self.file_systems.unwrap_or_default();
            v.push(input.into());
            self.file_systems = Some(v);
            self
        }
        /// <p>An array of file system descriptions.</p>
        pub fn set_file_systems(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::FileSystem>>,
        ) -> Self {
            self.file_systems = input;
            self
        }
        /// <p>Present if there are more file systems than returned in the response (String). You
        /// can use the <code>NextToken</code> value in the later request to fetch the
        /// descriptions. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>Present if there are more file systems than returned in the response (String). You
        /// can use the <code>NextToken</code> value in the later request to fetch the
        /// descriptions. </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 [`DescribeFileSystemsOutput`](crate::output::DescribeFileSystemsOutput)
        pub fn build(self) -> crate::output::DescribeFileSystemsOutput {
            crate::output::DescribeFileSystemsOutput {
                file_systems: self.file_systems,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeFileSystemsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeFileSystemsOutput`](crate::output::DescribeFileSystemsOutput)
    pub fn builder() -> crate::output::describe_file_systems_output::Builder {
        crate::output::describe_file_systems_output::Builder::default()
    }
}

/// <p>The response object for <code>DescribeFileSystemAliases</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeFileSystemAliasesOutput {
    /// <p>An array of one or more DNS aliases currently associated with the specified file system.</p>
    pub aliases: std::option::Option<std::vec::Vec<crate::model::Alias>>,
    /// <p>Present if there are more DNS aliases than returned in the response (String). You
    /// can use the <code>NextToken</code> value in a later request to fetch additional
    /// descriptions. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeFileSystemAliasesOutput {
    /// <p>An array of one or more DNS aliases currently associated with the specified file system.</p>
    pub fn aliases(&self) -> std::option::Option<&[crate::model::Alias]> {
        self.aliases.as_deref()
    }
    /// <p>Present if there are more DNS aliases than returned in the response (String). You
    /// can use the <code>NextToken</code> value in a later request to fetch additional
    /// descriptions. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeFileSystemAliasesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeFileSystemAliasesOutput");
        formatter.field("aliases", &self.aliases);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeFileSystemAliasesOutput`](crate::output::DescribeFileSystemAliasesOutput)
pub mod describe_file_system_aliases_output {
    /// A builder for [`DescribeFileSystemAliasesOutput`](crate::output::DescribeFileSystemAliasesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aliases: std::option::Option<std::vec::Vec<crate::model::Alias>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `aliases`.
        ///
        /// To override the contents of this collection use [`set_aliases`](Self::set_aliases).
        ///
        /// <p>An array of one or more DNS aliases currently associated with the specified file system.</p>
        pub fn aliases(mut self, input: impl Into<crate::model::Alias>) -> Self {
            let mut v = self.aliases.unwrap_or_default();
            v.push(input.into());
            self.aliases = Some(v);
            self
        }
        /// <p>An array of one or more DNS aliases currently associated with the specified file system.</p>
        pub fn set_aliases(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Alias>>,
        ) -> Self {
            self.aliases = input;
            self
        }
        /// <p>Present if there are more DNS aliases than returned in the response (String). You
        /// can use the <code>NextToken</code> value in a later request to fetch additional
        /// descriptions. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>Present if there are more DNS aliases than returned in the response (String). You
        /// can use the <code>NextToken</code> value in a later request to fetch additional
        /// descriptions. </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 [`DescribeFileSystemAliasesOutput`](crate::output::DescribeFileSystemAliasesOutput)
        pub fn build(self) -> crate::output::DescribeFileSystemAliasesOutput {
            crate::output::DescribeFileSystemAliasesOutput {
                aliases: self.aliases,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeFileSystemAliasesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeFileSystemAliasesOutput`](crate::output::DescribeFileSystemAliasesOutput)
    pub fn builder() -> crate::output::describe_file_system_aliases_output::Builder {
        crate::output::describe_file_system_aliases_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeDataRepositoryTasksOutput {
    /// <p>The collection of data repository task descriptions returned.</p>
    pub data_repository_tasks: std::option::Option<std::vec::Vec<crate::model::DataRepositoryTask>>,
    /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
    /// present, this token indicates from what point you can continue processing the request, where
    /// the previous <code>NextToken</code> value left off.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeDataRepositoryTasksOutput {
    /// <p>The collection of data repository task descriptions returned.</p>
    pub fn data_repository_tasks(
        &self,
    ) -> std::option::Option<&[crate::model::DataRepositoryTask]> {
        self.data_repository_tasks.as_deref()
    }
    /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
    /// present, this token indicates from what point you can continue processing the request, where
    /// the previous <code>NextToken</code> value left off.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeDataRepositoryTasksOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeDataRepositoryTasksOutput");
        formatter.field("data_repository_tasks", &self.data_repository_tasks);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeDataRepositoryTasksOutput`](crate::output::DescribeDataRepositoryTasksOutput)
pub mod describe_data_repository_tasks_output {
    /// A builder for [`DescribeDataRepositoryTasksOutput`](crate::output::DescribeDataRepositoryTasksOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) data_repository_tasks:
            std::option::Option<std::vec::Vec<crate::model::DataRepositoryTask>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `data_repository_tasks`.
        ///
        /// To override the contents of this collection use [`set_data_repository_tasks`](Self::set_data_repository_tasks).
        ///
        /// <p>The collection of data repository task descriptions returned.</p>
        pub fn data_repository_tasks(
            mut self,
            input: impl Into<crate::model::DataRepositoryTask>,
        ) -> Self {
            let mut v = self.data_repository_tasks.unwrap_or_default();
            v.push(input.into());
            self.data_repository_tasks = Some(v);
            self
        }
        /// <p>The collection of data repository task descriptions returned.</p>
        pub fn set_data_repository_tasks(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DataRepositoryTask>>,
        ) -> Self {
            self.data_repository_tasks = input;
            self
        }
        /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
        /// present, this token indicates from what point you can continue processing the request, where
        /// the previous <code>NextToken</code> value left off.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>(Optional) Opaque pagination token returned from a previous operation (String). If
        /// present, this token indicates from what point you can continue processing the request, where
        /// the previous <code>NextToken</code> value left off.</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 [`DescribeDataRepositoryTasksOutput`](crate::output::DescribeDataRepositoryTasksOutput)
        pub fn build(self) -> crate::output::DescribeDataRepositoryTasksOutput {
            crate::output::DescribeDataRepositoryTasksOutput {
                data_repository_tasks: self.data_repository_tasks,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeDataRepositoryTasksOutput {
    /// Creates a new builder-style object to manufacture [`DescribeDataRepositoryTasksOutput`](crate::output::DescribeDataRepositoryTasksOutput)
    pub fn builder() -> crate::output::describe_data_repository_tasks_output::Builder {
        crate::output::describe_data_repository_tasks_output::Builder::default()
    }
}

/// <p>Response object for <code>DescribeBackups</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeBackupsOutput {
    /// <p>An array of backups.</p>
    pub backups: std::option::Option<std::vec::Vec<crate::model::Backup>>,
    /// <p>This is present if there are more backups than returned in the response (String).
    /// You can use the <code>NextToken</code> value in the later request to fetch the backups.
    /// </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeBackupsOutput {
    /// <p>An array of backups.</p>
    pub fn backups(&self) -> std::option::Option<&[crate::model::Backup]> {
        self.backups.as_deref()
    }
    /// <p>This is present if there are more backups than returned in the response (String).
    /// You can use the <code>NextToken</code> value in the later request to fetch the backups.
    /// </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeBackupsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeBackupsOutput");
        formatter.field("backups", &self.backups);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeBackupsOutput`](crate::output::DescribeBackupsOutput)
pub mod describe_backups_output {
    /// A builder for [`DescribeBackupsOutput`](crate::output::DescribeBackupsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) backups: std::option::Option<std::vec::Vec<crate::model::Backup>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `backups`.
        ///
        /// To override the contents of this collection use [`set_backups`](Self::set_backups).
        ///
        /// <p>An array of backups.</p>
        pub fn backups(mut self, input: impl Into<crate::model::Backup>) -> Self {
            let mut v = self.backups.unwrap_or_default();
            v.push(input.into());
            self.backups = Some(v);
            self
        }
        /// <p>An array of backups.</p>
        pub fn set_backups(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Backup>>,
        ) -> Self {
            self.backups = input;
            self
        }
        /// <p>This is present if there are more backups than returned in the response (String).
        /// You can use the <code>NextToken</code> value in the later request to fetch the backups.
        /// </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>This is present if there are more backups than returned in the response (String).
        /// You can use the <code>NextToken</code> value in the later request to fetch the backups.
        /// </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 [`DescribeBackupsOutput`](crate::output::DescribeBackupsOutput)
        pub fn build(self) -> crate::output::DescribeBackupsOutput {
            crate::output::DescribeBackupsOutput {
                backups: self.backups,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeBackupsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeBackupsOutput`](crate::output::DescribeBackupsOutput)
    pub fn builder() -> crate::output::describe_backups_output::Builder {
        crate::output::describe_backups_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteVolumeOutput {
    /// <p>The ID of the volume being deleted.</p>
    pub volume_id: std::option::Option<std::string::String>,
    /// <p>Describes the lifecycle state of the volume being deleted.</p>
    pub lifecycle: std::option::Option<crate::model::VolumeLifecycle>,
    /// <p>Returned after a <code>DeleteVolume request, showing the status of the delete request.</code>
    /// </p>
    pub ontap_response: std::option::Option<crate::model::DeleteVolumeOntapResponse>,
}
impl DeleteVolumeOutput {
    /// <p>The ID of the volume being deleted.</p>
    pub fn volume_id(&self) -> std::option::Option<&str> {
        self.volume_id.as_deref()
    }
    /// <p>Describes the lifecycle state of the volume being deleted.</p>
    pub fn lifecycle(&self) -> std::option::Option<&crate::model::VolumeLifecycle> {
        self.lifecycle.as_ref()
    }
    /// <p>Returned after a <code>DeleteVolume request, showing the status of the delete request.</code>
    /// </p>
    pub fn ontap_response(&self) -> std::option::Option<&crate::model::DeleteVolumeOntapResponse> {
        self.ontap_response.as_ref()
    }
}
impl std::fmt::Debug for DeleteVolumeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteVolumeOutput");
        formatter.field("volume_id", &self.volume_id);
        formatter.field("lifecycle", &self.lifecycle);
        formatter.field("ontap_response", &self.ontap_response);
        formatter.finish()
    }
}
/// See [`DeleteVolumeOutput`](crate::output::DeleteVolumeOutput)
pub mod delete_volume_output {
    /// A builder for [`DeleteVolumeOutput`](crate::output::DeleteVolumeOutput)
    #[non_exhaustive]
    #[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>,
        pub(crate) lifecycle: std::option::Option<crate::model::VolumeLifecycle>,
        pub(crate) ontap_response: std::option::Option<crate::model::DeleteVolumeOntapResponse>,
    }
    impl Builder {
        /// <p>The ID of the volume being deleted.</p>
        pub fn volume_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.volume_id = Some(input.into());
            self
        }
        /// <p>The ID of the volume being deleted.</p>
        pub fn set_volume_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.volume_id = input;
            self
        }
        /// <p>Describes the lifecycle state of the volume being deleted.</p>
        pub fn lifecycle(mut self, input: crate::model::VolumeLifecycle) -> Self {
            self.lifecycle = Some(input);
            self
        }
        /// <p>Describes the lifecycle state of the volume being deleted.</p>
        pub fn set_lifecycle(
            mut self,
            input: std::option::Option<crate::model::VolumeLifecycle>,
        ) -> Self {
            self.lifecycle = input;
            self
        }
        /// <p>Returned after a <code>DeleteVolume request, showing the status of the delete request.</code>
        /// </p>
        pub fn ontap_response(mut self, input: crate::model::DeleteVolumeOntapResponse) -> Self {
            self.ontap_response = Some(input);
            self
        }
        /// <p>Returned after a <code>DeleteVolume request, showing the status of the delete request.</code>
        /// </p>
        pub fn set_ontap_response(
            mut self,
            input: std::option::Option<crate::model::DeleteVolumeOntapResponse>,
        ) -> Self {
            self.ontap_response = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteVolumeOutput`](crate::output::DeleteVolumeOutput)
        pub fn build(self) -> crate::output::DeleteVolumeOutput {
            crate::output::DeleteVolumeOutput {
                volume_id: self.volume_id,
                lifecycle: self.lifecycle,
                ontap_response: self.ontap_response,
            }
        }
    }
}
impl DeleteVolumeOutput {
    /// Creates a new builder-style object to manufacture [`DeleteVolumeOutput`](crate::output::DeleteVolumeOutput)
    pub fn builder() -> crate::output::delete_volume_output::Builder {
        crate::output::delete_volume_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteStorageVirtualMachineOutput {
    /// <p>The ID of the SVM Amazon FSx is deleting.</p>
    pub storage_virtual_machine_id: std::option::Option<std::string::String>,
    /// <p>Describes the lifecycle state of the SVM being deleted.</p>
    pub lifecycle: std::option::Option<crate::model::StorageVirtualMachineLifecycle>,
}
impl DeleteStorageVirtualMachineOutput {
    /// <p>The ID of the SVM Amazon FSx is deleting.</p>
    pub fn storage_virtual_machine_id(&self) -> std::option::Option<&str> {
        self.storage_virtual_machine_id.as_deref()
    }
    /// <p>Describes the lifecycle state of the SVM being deleted.</p>
    pub fn lifecycle(&self) -> std::option::Option<&crate::model::StorageVirtualMachineLifecycle> {
        self.lifecycle.as_ref()
    }
}
impl std::fmt::Debug for DeleteStorageVirtualMachineOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteStorageVirtualMachineOutput");
        formatter.field(
            "storage_virtual_machine_id",
            &self.storage_virtual_machine_id,
        );
        formatter.field("lifecycle", &self.lifecycle);
        formatter.finish()
    }
}
/// See [`DeleteStorageVirtualMachineOutput`](crate::output::DeleteStorageVirtualMachineOutput)
pub mod delete_storage_virtual_machine_output {
    /// A builder for [`DeleteStorageVirtualMachineOutput`](crate::output::DeleteStorageVirtualMachineOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) storage_virtual_machine_id: std::option::Option<std::string::String>,
        pub(crate) lifecycle: std::option::Option<crate::model::StorageVirtualMachineLifecycle>,
    }
    impl Builder {
        /// <p>The ID of the SVM Amazon FSx is deleting.</p>
        pub fn storage_virtual_machine_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.storage_virtual_machine_id = Some(input.into());
            self
        }
        /// <p>The ID of the SVM Amazon FSx is deleting.</p>
        pub fn set_storage_virtual_machine_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.storage_virtual_machine_id = input;
            self
        }
        /// <p>Describes the lifecycle state of the SVM being deleted.</p>
        pub fn lifecycle(mut self, input: crate::model::StorageVirtualMachineLifecycle) -> Self {
            self.lifecycle = Some(input);
            self
        }
        /// <p>Describes the lifecycle state of the SVM being deleted.</p>
        pub fn set_lifecycle(
            mut self,
            input: std::option::Option<crate::model::StorageVirtualMachineLifecycle>,
        ) -> Self {
            self.lifecycle = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteStorageVirtualMachineOutput`](crate::output::DeleteStorageVirtualMachineOutput)
        pub fn build(self) -> crate::output::DeleteStorageVirtualMachineOutput {
            crate::output::DeleteStorageVirtualMachineOutput {
                storage_virtual_machine_id: self.storage_virtual_machine_id,
                lifecycle: self.lifecycle,
            }
        }
    }
}
impl DeleteStorageVirtualMachineOutput {
    /// Creates a new builder-style object to manufacture [`DeleteStorageVirtualMachineOutput`](crate::output::DeleteStorageVirtualMachineOutput)
    pub fn builder() -> crate::output::delete_storage_virtual_machine_output::Builder {
        crate::output::delete_storage_virtual_machine_output::Builder::default()
    }
}

/// <p>The response object for the <code>DeleteFileSystem</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteFileSystemOutput {
    /// <p>The ID of the file system being deleted.</p>
    pub file_system_id: std::option::Option<std::string::String>,
    /// <p>The file system lifecycle for the deletion request. Should be
    /// <code>DELETING</code>.</p>
    pub lifecycle: std::option::Option<crate::model::FileSystemLifecycle>,
    /// <p>The response object for the Microsoft Windows file system used in the
    /// <code>DeleteFileSystem</code> operation.</p>
    pub windows_response: std::option::Option<crate::model::DeleteFileSystemWindowsResponse>,
    /// <p>The response object for the Amazon FSx for Lustre file system being deleted in the
    /// <code>DeleteFileSystem</code> operation.</p>
    pub lustre_response: std::option::Option<crate::model::DeleteFileSystemLustreResponse>,
}
impl DeleteFileSystemOutput {
    /// <p>The ID of the file system being deleted.</p>
    pub fn file_system_id(&self) -> std::option::Option<&str> {
        self.file_system_id.as_deref()
    }
    /// <p>The file system lifecycle for the deletion request. Should be
    /// <code>DELETING</code>.</p>
    pub fn lifecycle(&self) -> std::option::Option<&crate::model::FileSystemLifecycle> {
        self.lifecycle.as_ref()
    }
    /// <p>The response object for the Microsoft Windows file system used in the
    /// <code>DeleteFileSystem</code> operation.</p>
    pub fn windows_response(
        &self,
    ) -> std::option::Option<&crate::model::DeleteFileSystemWindowsResponse> {
        self.windows_response.as_ref()
    }
    /// <p>The response object for the Amazon FSx for Lustre file system being deleted in the
    /// <code>DeleteFileSystem</code> operation.</p>
    pub fn lustre_response(
        &self,
    ) -> std::option::Option<&crate::model::DeleteFileSystemLustreResponse> {
        self.lustre_response.as_ref()
    }
}
impl std::fmt::Debug for DeleteFileSystemOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteFileSystemOutput");
        formatter.field("file_system_id", &self.file_system_id);
        formatter.field("lifecycle", &self.lifecycle);
        formatter.field("windows_response", &self.windows_response);
        formatter.field("lustre_response", &self.lustre_response);
        formatter.finish()
    }
}
/// See [`DeleteFileSystemOutput`](crate::output::DeleteFileSystemOutput)
pub mod delete_file_system_output {
    /// A builder for [`DeleteFileSystemOutput`](crate::output::DeleteFileSystemOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) file_system_id: std::option::Option<std::string::String>,
        pub(crate) lifecycle: std::option::Option<crate::model::FileSystemLifecycle>,
        pub(crate) windows_response:
            std::option::Option<crate::model::DeleteFileSystemWindowsResponse>,
        pub(crate) lustre_response:
            std::option::Option<crate::model::DeleteFileSystemLustreResponse>,
    }
    impl Builder {
        /// <p>The ID of the file system being deleted.</p>
        pub fn file_system_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.file_system_id = Some(input.into());
            self
        }
        /// <p>The ID of the file system being deleted.</p>
        pub fn set_file_system_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.file_system_id = input;
            self
        }
        /// <p>The file system lifecycle for the deletion request. Should be
        /// <code>DELETING</code>.</p>
        pub fn lifecycle(mut self, input: crate::model::FileSystemLifecycle) -> Self {
            self.lifecycle = Some(input);
            self
        }
        /// <p>The file system lifecycle for the deletion request. Should be
        /// <code>DELETING</code>.</p>
        pub fn set_lifecycle(
            mut self,
            input: std::option::Option<crate::model::FileSystemLifecycle>,
        ) -> Self {
            self.lifecycle = input;
            self
        }
        /// <p>The response object for the Microsoft Windows file system used in the
        /// <code>DeleteFileSystem</code> operation.</p>
        pub fn windows_response(
            mut self,
            input: crate::model::DeleteFileSystemWindowsResponse,
        ) -> Self {
            self.windows_response = Some(input);
            self
        }
        /// <p>The response object for the Microsoft Windows file system used in the
        /// <code>DeleteFileSystem</code> operation.</p>
        pub fn set_windows_response(
            mut self,
            input: std::option::Option<crate::model::DeleteFileSystemWindowsResponse>,
        ) -> Self {
            self.windows_response = input;
            self
        }
        /// <p>The response object for the Amazon FSx for Lustre file system being deleted in the
        /// <code>DeleteFileSystem</code> operation.</p>
        pub fn lustre_response(
            mut self,
            input: crate::model::DeleteFileSystemLustreResponse,
        ) -> Self {
            self.lustre_response = Some(input);
            self
        }
        /// <p>The response object for the Amazon FSx for Lustre file system being deleted in the
        /// <code>DeleteFileSystem</code> operation.</p>
        pub fn set_lustre_response(
            mut self,
            input: std::option::Option<crate::model::DeleteFileSystemLustreResponse>,
        ) -> Self {
            self.lustre_response = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteFileSystemOutput`](crate::output::DeleteFileSystemOutput)
        pub fn build(self) -> crate::output::DeleteFileSystemOutput {
            crate::output::DeleteFileSystemOutput {
                file_system_id: self.file_system_id,
                lifecycle: self.lifecycle,
                windows_response: self.windows_response,
                lustre_response: self.lustre_response,
            }
        }
    }
}
impl DeleteFileSystemOutput {
    /// Creates a new builder-style object to manufacture [`DeleteFileSystemOutput`](crate::output::DeleteFileSystemOutput)
    pub fn builder() -> crate::output::delete_file_system_output::Builder {
        crate::output::delete_file_system_output::Builder::default()
    }
}

/// <p>The response object for <code>DeleteBackup</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteBackupOutput {
    /// <p>The ID of the backup deleted.</p>
    pub backup_id: std::option::Option<std::string::String>,
    /// <p>The lifecycle of the backup. Should be <code>DELETED</code>.</p>
    pub lifecycle: std::option::Option<crate::model::BackupLifecycle>,
}
impl DeleteBackupOutput {
    /// <p>The ID of the backup deleted.</p>
    pub fn backup_id(&self) -> std::option::Option<&str> {
        self.backup_id.as_deref()
    }
    /// <p>The lifecycle of the backup. Should be <code>DELETED</code>.</p>
    pub fn lifecycle(&self) -> std::option::Option<&crate::model::BackupLifecycle> {
        self.lifecycle.as_ref()
    }
}
impl std::fmt::Debug for DeleteBackupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteBackupOutput");
        formatter.field("backup_id", &self.backup_id);
        formatter.field("lifecycle", &self.lifecycle);
        formatter.finish()
    }
}
/// See [`DeleteBackupOutput`](crate::output::DeleteBackupOutput)
pub mod delete_backup_output {
    /// A builder for [`DeleteBackupOutput`](crate::output::DeleteBackupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) backup_id: std::option::Option<std::string::String>,
        pub(crate) lifecycle: std::option::Option<crate::model::BackupLifecycle>,
    }
    impl Builder {
        /// <p>The ID of the backup deleted.</p>
        pub fn backup_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.backup_id = Some(input.into());
            self
        }
        /// <p>The ID of the backup deleted.</p>
        pub fn set_backup_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.backup_id = input;
            self
        }
        /// <p>The lifecycle of the backup. Should be <code>DELETED</code>.</p>
        pub fn lifecycle(mut self, input: crate::model::BackupLifecycle) -> Self {
            self.lifecycle = Some(input);
            self
        }
        /// <p>The lifecycle of the backup. Should be <code>DELETED</code>.</p>
        pub fn set_lifecycle(
            mut self,
            input: std::option::Option<crate::model::BackupLifecycle>,
        ) -> Self {
            self.lifecycle = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteBackupOutput`](crate::output::DeleteBackupOutput)
        pub fn build(self) -> crate::output::DeleteBackupOutput {
            crate::output::DeleteBackupOutput {
                backup_id: self.backup_id,
                lifecycle: self.lifecycle,
            }
        }
    }
}
impl DeleteBackupOutput {
    /// Creates a new builder-style object to manufacture [`DeleteBackupOutput`](crate::output::DeleteBackupOutput)
    pub fn builder() -> crate::output::delete_backup_output::Builder {
        crate::output::delete_backup_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateVolumeFromBackupOutput {
    /// <p>Returned after a successful <code>CreateVolumeFromBackup</code> API operation,
    /// describing the volume just created.</p>
    pub volume: std::option::Option<crate::model::Volume>,
}
impl CreateVolumeFromBackupOutput {
    /// <p>Returned after a successful <code>CreateVolumeFromBackup</code> API operation,
    /// describing the volume just created.</p>
    pub fn volume(&self) -> std::option::Option<&crate::model::Volume> {
        self.volume.as_ref()
    }
}
impl std::fmt::Debug for CreateVolumeFromBackupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateVolumeFromBackupOutput");
        formatter.field("volume", &self.volume);
        formatter.finish()
    }
}
/// See [`CreateVolumeFromBackupOutput`](crate::output::CreateVolumeFromBackupOutput)
pub mod create_volume_from_backup_output {
    /// A builder for [`CreateVolumeFromBackupOutput`](crate::output::CreateVolumeFromBackupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) volume: std::option::Option<crate::model::Volume>,
    }
    impl Builder {
        /// <p>Returned after a successful <code>CreateVolumeFromBackup</code> API operation,
        /// describing the volume just created.</p>
        pub fn volume(mut self, input: crate::model::Volume) -> Self {
            self.volume = Some(input);
            self
        }
        /// <p>Returned after a successful <code>CreateVolumeFromBackup</code> API operation,
        /// describing the volume just created.</p>
        pub fn set_volume(mut self, input: std::option::Option<crate::model::Volume>) -> Self {
            self.volume = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateVolumeFromBackupOutput`](crate::output::CreateVolumeFromBackupOutput)
        pub fn build(self) -> crate::output::CreateVolumeFromBackupOutput {
            crate::output::CreateVolumeFromBackupOutput {
                volume: self.volume,
            }
        }
    }
}
impl CreateVolumeFromBackupOutput {
    /// Creates a new builder-style object to manufacture [`CreateVolumeFromBackupOutput`](crate::output::CreateVolumeFromBackupOutput)
    pub fn builder() -> crate::output::create_volume_from_backup_output::Builder {
        crate::output::create_volume_from_backup_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateVolumeOutput {
    /// <p>Returned after a successful <code>CreateVolume</code> API operation, describing the volume just created.</p>
    pub volume: std::option::Option<crate::model::Volume>,
}
impl CreateVolumeOutput {
    /// <p>Returned after a successful <code>CreateVolume</code> API operation, describing the volume just created.</p>
    pub fn volume(&self) -> std::option::Option<&crate::model::Volume> {
        self.volume.as_ref()
    }
}
impl std::fmt::Debug for CreateVolumeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateVolumeOutput");
        formatter.field("volume", &self.volume);
        formatter.finish()
    }
}
/// See [`CreateVolumeOutput`](crate::output::CreateVolumeOutput)
pub mod create_volume_output {
    /// A builder for [`CreateVolumeOutput`](crate::output::CreateVolumeOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) volume: std::option::Option<crate::model::Volume>,
    }
    impl Builder {
        /// <p>Returned after a successful <code>CreateVolume</code> API operation, describing the volume just created.</p>
        pub fn volume(mut self, input: crate::model::Volume) -> Self {
            self.volume = Some(input);
            self
        }
        /// <p>Returned after a successful <code>CreateVolume</code> API operation, describing the volume just created.</p>
        pub fn set_volume(mut self, input: std::option::Option<crate::model::Volume>) -> Self {
            self.volume = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateVolumeOutput`](crate::output::CreateVolumeOutput)
        pub fn build(self) -> crate::output::CreateVolumeOutput {
            crate::output::CreateVolumeOutput {
                volume: self.volume,
            }
        }
    }
}
impl CreateVolumeOutput {
    /// Creates a new builder-style object to manufacture [`CreateVolumeOutput`](crate::output::CreateVolumeOutput)
    pub fn builder() -> crate::output::create_volume_output::Builder {
        crate::output::create_volume_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateStorageVirtualMachineOutput {
    /// <p>Returned after a successful <code>CreateStorageVirtualMachine</code> operation; describes the SVM just created.</p>
    pub storage_virtual_machine: std::option::Option<crate::model::StorageVirtualMachine>,
}
impl CreateStorageVirtualMachineOutput {
    /// <p>Returned after a successful <code>CreateStorageVirtualMachine</code> operation; describes the SVM just created.</p>
    pub fn storage_virtual_machine(
        &self,
    ) -> std::option::Option<&crate::model::StorageVirtualMachine> {
        self.storage_virtual_machine.as_ref()
    }
}
impl std::fmt::Debug for CreateStorageVirtualMachineOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateStorageVirtualMachineOutput");
        formatter.field("storage_virtual_machine", &self.storage_virtual_machine);
        formatter.finish()
    }
}
/// See [`CreateStorageVirtualMachineOutput`](crate::output::CreateStorageVirtualMachineOutput)
pub mod create_storage_virtual_machine_output {
    /// A builder for [`CreateStorageVirtualMachineOutput`](crate::output::CreateStorageVirtualMachineOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) storage_virtual_machine:
            std::option::Option<crate::model::StorageVirtualMachine>,
    }
    impl Builder {
        /// <p>Returned after a successful <code>CreateStorageVirtualMachine</code> operation; describes the SVM just created.</p>
        pub fn storage_virtual_machine(
            mut self,
            input: crate::model::StorageVirtualMachine,
        ) -> Self {
            self.storage_virtual_machine = Some(input);
            self
        }
        /// <p>Returned after a successful <code>CreateStorageVirtualMachine</code> operation; describes the SVM just created.</p>
        pub fn set_storage_virtual_machine(
            mut self,
            input: std::option::Option<crate::model::StorageVirtualMachine>,
        ) -> Self {
            self.storage_virtual_machine = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateStorageVirtualMachineOutput`](crate::output::CreateStorageVirtualMachineOutput)
        pub fn build(self) -> crate::output::CreateStorageVirtualMachineOutput {
            crate::output::CreateStorageVirtualMachineOutput {
                storage_virtual_machine: self.storage_virtual_machine,
            }
        }
    }
}
impl CreateStorageVirtualMachineOutput {
    /// Creates a new builder-style object to manufacture [`CreateStorageVirtualMachineOutput`](crate::output::CreateStorageVirtualMachineOutput)
    pub fn builder() -> crate::output::create_storage_virtual_machine_output::Builder {
        crate::output::create_storage_virtual_machine_output::Builder::default()
    }
}

/// <p>The response object for the <code>CreateFileSystemFromBackup</code>
/// operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateFileSystemFromBackupOutput {
    /// <p>A description of the file system.</p>
    pub file_system: std::option::Option<crate::model::FileSystem>,
}
impl CreateFileSystemFromBackupOutput {
    /// <p>A description of the file system.</p>
    pub fn file_system(&self) -> std::option::Option<&crate::model::FileSystem> {
        self.file_system.as_ref()
    }
}
impl std::fmt::Debug for CreateFileSystemFromBackupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateFileSystemFromBackupOutput");
        formatter.field("file_system", &self.file_system);
        formatter.finish()
    }
}
/// See [`CreateFileSystemFromBackupOutput`](crate::output::CreateFileSystemFromBackupOutput)
pub mod create_file_system_from_backup_output {
    /// A builder for [`CreateFileSystemFromBackupOutput`](crate::output::CreateFileSystemFromBackupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) file_system: std::option::Option<crate::model::FileSystem>,
    }
    impl Builder {
        /// <p>A description of the file system.</p>
        pub fn file_system(mut self, input: crate::model::FileSystem) -> Self {
            self.file_system = Some(input);
            self
        }
        /// <p>A description of the file system.</p>
        pub fn set_file_system(
            mut self,
            input: std::option::Option<crate::model::FileSystem>,
        ) -> Self {
            self.file_system = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateFileSystemFromBackupOutput`](crate::output::CreateFileSystemFromBackupOutput)
        pub fn build(self) -> crate::output::CreateFileSystemFromBackupOutput {
            crate::output::CreateFileSystemFromBackupOutput {
                file_system: self.file_system,
            }
        }
    }
}
impl CreateFileSystemFromBackupOutput {
    /// Creates a new builder-style object to manufacture [`CreateFileSystemFromBackupOutput`](crate::output::CreateFileSystemFromBackupOutput)
    pub fn builder() -> crate::output::create_file_system_from_backup_output::Builder {
        crate::output::create_file_system_from_backup_output::Builder::default()
    }
}

/// <p>The response object returned after the file system is created.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateFileSystemOutput {
    /// <p>The configuration of the file system that was created.</p>
    pub file_system: std::option::Option<crate::model::FileSystem>,
}
impl CreateFileSystemOutput {
    /// <p>The configuration of the file system that was created.</p>
    pub fn file_system(&self) -> std::option::Option<&crate::model::FileSystem> {
        self.file_system.as_ref()
    }
}
impl std::fmt::Debug for CreateFileSystemOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateFileSystemOutput");
        formatter.field("file_system", &self.file_system);
        formatter.finish()
    }
}
/// See [`CreateFileSystemOutput`](crate::output::CreateFileSystemOutput)
pub mod create_file_system_output {
    /// A builder for [`CreateFileSystemOutput`](crate::output::CreateFileSystemOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) file_system: std::option::Option<crate::model::FileSystem>,
    }
    impl Builder {
        /// <p>The configuration of the file system that was created.</p>
        pub fn file_system(mut self, input: crate::model::FileSystem) -> Self {
            self.file_system = Some(input);
            self
        }
        /// <p>The configuration of the file system that was created.</p>
        pub fn set_file_system(
            mut self,
            input: std::option::Option<crate::model::FileSystem>,
        ) -> Self {
            self.file_system = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateFileSystemOutput`](crate::output::CreateFileSystemOutput)
        pub fn build(self) -> crate::output::CreateFileSystemOutput {
            crate::output::CreateFileSystemOutput {
                file_system: self.file_system,
            }
        }
    }
}
impl CreateFileSystemOutput {
    /// Creates a new builder-style object to manufacture [`CreateFileSystemOutput`](crate::output::CreateFileSystemOutput)
    pub fn builder() -> crate::output::create_file_system_output::Builder {
        crate::output::create_file_system_output::Builder::default()
    }
}

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

/// <p>The response object for the <code>CreateBackup</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateBackupOutput {
    /// <p>A description of the backup.</p>
    pub backup: std::option::Option<crate::model::Backup>,
}
impl CreateBackupOutput {
    /// <p>A description of the backup.</p>
    pub fn backup(&self) -> std::option::Option<&crate::model::Backup> {
        self.backup.as_ref()
    }
}
impl std::fmt::Debug for CreateBackupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateBackupOutput");
        formatter.field("backup", &self.backup);
        formatter.finish()
    }
}
/// See [`CreateBackupOutput`](crate::output::CreateBackupOutput)
pub mod create_backup_output {
    /// A builder for [`CreateBackupOutput`](crate::output::CreateBackupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) backup: std::option::Option<crate::model::Backup>,
    }
    impl Builder {
        /// <p>A description of the backup.</p>
        pub fn backup(mut self, input: crate::model::Backup) -> Self {
            self.backup = Some(input);
            self
        }
        /// <p>A description of the backup.</p>
        pub fn set_backup(mut self, input: std::option::Option<crate::model::Backup>) -> Self {
            self.backup = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateBackupOutput`](crate::output::CreateBackupOutput)
        pub fn build(self) -> crate::output::CreateBackupOutput {
            crate::output::CreateBackupOutput {
                backup: self.backup,
            }
        }
    }
}
impl CreateBackupOutput {
    /// Creates a new builder-style object to manufacture [`CreateBackupOutput`](crate::output::CreateBackupOutput)
    pub fn builder() -> crate::output::create_backup_output::Builder {
        crate::output::create_backup_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CopyBackupOutput {
    /// <p>A backup of an Amazon FSx for Windows File Server or Amazon FSx for Lustre file system,
    /// or of an Amazon FSx for NetApp ONTAP volume.</p>
    pub backup: std::option::Option<crate::model::Backup>,
}
impl CopyBackupOutput {
    /// <p>A backup of an Amazon FSx for Windows File Server or Amazon FSx for Lustre file system,
    /// or of an Amazon FSx for NetApp ONTAP volume.</p>
    pub fn backup(&self) -> std::option::Option<&crate::model::Backup> {
        self.backup.as_ref()
    }
}
impl std::fmt::Debug for CopyBackupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CopyBackupOutput");
        formatter.field("backup", &self.backup);
        formatter.finish()
    }
}
/// See [`CopyBackupOutput`](crate::output::CopyBackupOutput)
pub mod copy_backup_output {
    /// A builder for [`CopyBackupOutput`](crate::output::CopyBackupOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) backup: std::option::Option<crate::model::Backup>,
    }
    impl Builder {
        /// <p>A backup of an Amazon FSx for Windows File Server or Amazon FSx for Lustre file system,
        /// or of an Amazon FSx for NetApp ONTAP volume.</p>
        pub fn backup(mut self, input: crate::model::Backup) -> Self {
            self.backup = Some(input);
            self
        }
        /// <p>A backup of an Amazon FSx for Windows File Server or Amazon FSx for Lustre file system,
        /// or of an Amazon FSx for NetApp ONTAP volume.</p>
        pub fn set_backup(mut self, input: std::option::Option<crate::model::Backup>) -> Self {
            self.backup = input;
            self
        }
        /// Consumes the builder and constructs a [`CopyBackupOutput`](crate::output::CopyBackupOutput)
        pub fn build(self) -> crate::output::CopyBackupOutput {
            crate::output::CopyBackupOutput {
                backup: self.backup,
            }
        }
    }
}
impl CopyBackupOutput {
    /// Creates a new builder-style object to manufacture [`CopyBackupOutput`](crate::output::CopyBackupOutput)
    pub fn builder() -> crate::output::copy_backup_output::Builder {
        crate::output::copy_backup_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CancelDataRepositoryTaskOutput {
    /// <p>The lifecycle status of the data repository task, as follows:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>PENDING</code> - Amazon FSx has not started the task.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>EXECUTING</code> - Amazon FSx is processing the task.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>FAILED</code> -  Amazon FSx was not able to complete the task. For example, there may be files the task failed to process.
    /// The <a>DataRepositoryTaskFailureDetails</a> property provides more information about task failures.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>SUCCEEDED</code> - FSx completed the task successfully.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>CANCELED</code> - Amazon FSx canceled the task and it did not complete.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>CANCELING</code> - FSx is in process of canceling the task.</p>
    /// </li>
    /// </ul>
    pub lifecycle: std::option::Option<crate::model::DataRepositoryTaskLifecycle>,
    /// <p>The ID of the task being canceled.</p>
    pub task_id: std::option::Option<std::string::String>,
}
impl CancelDataRepositoryTaskOutput {
    /// <p>The lifecycle status of the data repository task, as follows:</p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>PENDING</code> - Amazon FSx has not started the task.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>EXECUTING</code> - Amazon FSx is processing the task.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>FAILED</code> -  Amazon FSx was not able to complete the task. For example, there may be files the task failed to process.
    /// The <a>DataRepositoryTaskFailureDetails</a> property provides more information about task failures.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>SUCCEEDED</code> - FSx completed the task successfully.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>CANCELED</code> - Amazon FSx canceled the task and it did not complete.</p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>CANCELING</code> - FSx is in process of canceling the task.</p>
    /// </li>
    /// </ul>
    pub fn lifecycle(&self) -> std::option::Option<&crate::model::DataRepositoryTaskLifecycle> {
        self.lifecycle.as_ref()
    }
    /// <p>The ID of the task being canceled.</p>
    pub fn task_id(&self) -> std::option::Option<&str> {
        self.task_id.as_deref()
    }
}
impl std::fmt::Debug for CancelDataRepositoryTaskOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CancelDataRepositoryTaskOutput");
        formatter.field("lifecycle", &self.lifecycle);
        formatter.field("task_id", &self.task_id);
        formatter.finish()
    }
}
/// See [`CancelDataRepositoryTaskOutput`](crate::output::CancelDataRepositoryTaskOutput)
pub mod cancel_data_repository_task_output {
    /// A builder for [`CancelDataRepositoryTaskOutput`](crate::output::CancelDataRepositoryTaskOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) lifecycle: std::option::Option<crate::model::DataRepositoryTaskLifecycle>,
        pub(crate) task_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The lifecycle status of the data repository task, as follows:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>PENDING</code> - Amazon FSx has not started the task.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EXECUTING</code> - Amazon FSx is processing the task.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FAILED</code> -  Amazon FSx was not able to complete the task. For example, there may be files the task failed to process.
        /// The <a>DataRepositoryTaskFailureDetails</a> property provides more information about task failures.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>SUCCEEDED</code> - FSx completed the task successfully.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>CANCELED</code> - Amazon FSx canceled the task and it did not complete.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>CANCELING</code> - FSx is in process of canceling the task.</p>
        /// </li>
        /// </ul>
        pub fn lifecycle(mut self, input: crate::model::DataRepositoryTaskLifecycle) -> Self {
            self.lifecycle = Some(input);
            self
        }
        /// <p>The lifecycle status of the data repository task, as follows:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>PENDING</code> - Amazon FSx has not started the task.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EXECUTING</code> - Amazon FSx is processing the task.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FAILED</code> -  Amazon FSx was not able to complete the task. For example, there may be files the task failed to process.
        /// The <a>DataRepositoryTaskFailureDetails</a> property provides more information about task failures.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>SUCCEEDED</code> - FSx completed the task successfully.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>CANCELED</code> - Amazon FSx canceled the task and it did not complete.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>CANCELING</code> - FSx is in process of canceling the task.</p>
        /// </li>
        /// </ul>
        pub fn set_lifecycle(
            mut self,
            input: std::option::Option<crate::model::DataRepositoryTaskLifecycle>,
        ) -> Self {
            self.lifecycle = input;
            self
        }
        /// <p>The ID of the task being canceled.</p>
        pub fn task_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.task_id = Some(input.into());
            self
        }
        /// <p>The ID of the task being canceled.</p>
        pub fn set_task_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.task_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CancelDataRepositoryTaskOutput`](crate::output::CancelDataRepositoryTaskOutput)
        pub fn build(self) -> crate::output::CancelDataRepositoryTaskOutput {
            crate::output::CancelDataRepositoryTaskOutput {
                lifecycle: self.lifecycle,
                task_id: self.task_id,
            }
        }
    }
}
impl CancelDataRepositoryTaskOutput {
    /// Creates a new builder-style object to manufacture [`CancelDataRepositoryTaskOutput`](crate::output::CancelDataRepositoryTaskOutput)
    pub fn builder() -> crate::output::cancel_data_repository_task_output::Builder {
        crate::output::cancel_data_repository_task_output::Builder::default()
    }
}

/// <p>The system generated response showing the DNS aliases that
/// Amazon FSx is attempting to associate with the file system.
/// Use the  API
/// operation to monitor the status of the aliases Amazon FSx is
/// associating with the file system. It can take up to 2.5 minutes for
/// the alias status to change from <code>CREATING</code> to <code>AVAILABLE</code>. </p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateFileSystemAliasesOutput {
    /// <p>An array of the DNS aliases that Amazon FSx is associating with the file system.</p>
    pub aliases: std::option::Option<std::vec::Vec<crate::model::Alias>>,
}
impl AssociateFileSystemAliasesOutput {
    /// <p>An array of the DNS aliases that Amazon FSx is associating with the file system.</p>
    pub fn aliases(&self) -> std::option::Option<&[crate::model::Alias]> {
        self.aliases.as_deref()
    }
}
impl std::fmt::Debug for AssociateFileSystemAliasesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("AssociateFileSystemAliasesOutput");
        formatter.field("aliases", &self.aliases);
        formatter.finish()
    }
}
/// See [`AssociateFileSystemAliasesOutput`](crate::output::AssociateFileSystemAliasesOutput)
pub mod associate_file_system_aliases_output {
    /// A builder for [`AssociateFileSystemAliasesOutput`](crate::output::AssociateFileSystemAliasesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aliases: std::option::Option<std::vec::Vec<crate::model::Alias>>,
    }
    impl Builder {
        /// Appends an item to `aliases`.
        ///
        /// To override the contents of this collection use [`set_aliases`](Self::set_aliases).
        ///
        /// <p>An array of the DNS aliases that Amazon FSx is associating with the file system.</p>
        pub fn aliases(mut self, input: impl Into<crate::model::Alias>) -> Self {
            let mut v = self.aliases.unwrap_or_default();
            v.push(input.into());
            self.aliases = Some(v);
            self
        }
        /// <p>An array of the DNS aliases that Amazon FSx is associating with the file system.</p>
        pub fn set_aliases(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Alias>>,
        ) -> Self {
            self.aliases = input;
            self
        }
        /// Consumes the builder and constructs a [`AssociateFileSystemAliasesOutput`](crate::output::AssociateFileSystemAliasesOutput)
        pub fn build(self) -> crate::output::AssociateFileSystemAliasesOutput {
            crate::output::AssociateFileSystemAliasesOutput {
                aliases: self.aliases,
            }
        }
    }
}
impl AssociateFileSystemAliasesOutput {
    /// Creates a new builder-style object to manufacture [`AssociateFileSystemAliasesOutput`](crate::output::AssociateFileSystemAliasesOutput)
    pub fn builder() -> crate::output::associate_file_system_aliases_output::Builder {
        crate::output::associate_file_system_aliases_output::Builder::default()
    }
}