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 UpdateIdentityProviderConfigurationOutput {}
impl std::fmt::Debug for UpdateIdentityProviderConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateIdentityProviderConfigurationOutput");
        formatter.finish()
    }
}
/// See [`UpdateIdentityProviderConfigurationOutput`](crate::output::UpdateIdentityProviderConfigurationOutput)
pub mod update_identity_provider_configuration_output {
    /// A builder for [`UpdateIdentityProviderConfigurationOutput`](crate::output::UpdateIdentityProviderConfigurationOutput)
    #[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 [`UpdateIdentityProviderConfigurationOutput`](crate::output::UpdateIdentityProviderConfigurationOutput)
        pub fn build(self) -> crate::output::UpdateIdentityProviderConfigurationOutput {
            crate::output::UpdateIdentityProviderConfigurationOutput {}
        }
    }
}
impl UpdateIdentityProviderConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`UpdateIdentityProviderConfigurationOutput`](crate::output::UpdateIdentityProviderConfigurationOutput)
    pub fn builder() -> crate::output::update_identity_provider_configuration_output::Builder {
        crate::output::update_identity_provider_configuration_output::Builder::default()
    }
}

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

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

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

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

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListWebsiteCertificateAuthoritiesOutput {
    /// <p>Information about the certificates.</p>
    pub website_certificate_authorities:
        std::option::Option<std::vec::Vec<crate::model::WebsiteCaSummary>>,
    /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListWebsiteCertificateAuthoritiesOutput {
    /// <p>Information about the certificates.</p>
    pub fn website_certificate_authorities(
        &self,
    ) -> std::option::Option<&[crate::model::WebsiteCaSummary]> {
        self.website_certificate_authorities.as_deref()
    }
    /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListWebsiteCertificateAuthoritiesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListWebsiteCertificateAuthoritiesOutput");
        formatter.field(
            "website_certificate_authorities",
            &self.website_certificate_authorities,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListWebsiteCertificateAuthoritiesOutput`](crate::output::ListWebsiteCertificateAuthoritiesOutput)
pub mod list_website_certificate_authorities_output {
    /// A builder for [`ListWebsiteCertificateAuthoritiesOutput`](crate::output::ListWebsiteCertificateAuthoritiesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) website_certificate_authorities:
            std::option::Option<std::vec::Vec<crate::model::WebsiteCaSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `website_certificate_authorities`.
        ///
        /// To override the contents of this collection use [`set_website_certificate_authorities`](Self::set_website_certificate_authorities).
        ///
        /// <p>Information about the certificates.</p>
        pub fn website_certificate_authorities(
            mut self,
            input: crate::model::WebsiteCaSummary,
        ) -> Self {
            let mut v = self.website_certificate_authorities.unwrap_or_default();
            v.push(input);
            self.website_certificate_authorities = Some(v);
            self
        }
        /// <p>Information about the certificates.</p>
        pub fn set_website_certificate_authorities(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::WebsiteCaSummary>>,
        ) -> Self {
            self.website_certificate_authorities = input;
            self
        }
        /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</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 [`ListWebsiteCertificateAuthoritiesOutput`](crate::output::ListWebsiteCertificateAuthoritiesOutput)
        pub fn build(self) -> crate::output::ListWebsiteCertificateAuthoritiesOutput {
            crate::output::ListWebsiteCertificateAuthoritiesOutput {
                website_certificate_authorities: self.website_certificate_authorities,
                next_token: self.next_token,
            }
        }
    }
}
impl ListWebsiteCertificateAuthoritiesOutput {
    /// Creates a new builder-style object to manufacture [`ListWebsiteCertificateAuthoritiesOutput`](crate::output::ListWebsiteCertificateAuthoritiesOutput)
    pub fn builder() -> crate::output::list_website_certificate_authorities_output::Builder {
        crate::output::list_website_certificate_authorities_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListWebsiteAuthorizationProvidersOutput {
    /// <p>The website authorization providers.</p>
    pub website_authorization_providers:
        std::option::Option<std::vec::Vec<crate::model::WebsiteAuthorizationProviderSummary>>,
    /// <p>The pagination token to use to retrieve the next page of results for this operation. If this value is null, it retrieves the first page.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListWebsiteAuthorizationProvidersOutput {
    /// <p>The website authorization providers.</p>
    pub fn website_authorization_providers(
        &self,
    ) -> std::option::Option<&[crate::model::WebsiteAuthorizationProviderSummary]> {
        self.website_authorization_providers.as_deref()
    }
    /// <p>The pagination token to use to retrieve the next page of results for this operation. If this value is null, it retrieves the first page.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListWebsiteAuthorizationProvidersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListWebsiteAuthorizationProvidersOutput");
        formatter.field(
            "website_authorization_providers",
            &self.website_authorization_providers,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListWebsiteAuthorizationProvidersOutput`](crate::output::ListWebsiteAuthorizationProvidersOutput)
pub mod list_website_authorization_providers_output {
    /// A builder for [`ListWebsiteAuthorizationProvidersOutput`](crate::output::ListWebsiteAuthorizationProvidersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) website_authorization_providers:
            std::option::Option<std::vec::Vec<crate::model::WebsiteAuthorizationProviderSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `website_authorization_providers`.
        ///
        /// To override the contents of this collection use [`set_website_authorization_providers`](Self::set_website_authorization_providers).
        ///
        /// <p>The website authorization providers.</p>
        pub fn website_authorization_providers(
            mut self,
            input: crate::model::WebsiteAuthorizationProviderSummary,
        ) -> Self {
            let mut v = self.website_authorization_providers.unwrap_or_default();
            v.push(input);
            self.website_authorization_providers = Some(v);
            self
        }
        /// <p>The website authorization providers.</p>
        pub fn set_website_authorization_providers(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::WebsiteAuthorizationProviderSummary>,
            >,
        ) -> Self {
            self.website_authorization_providers = input;
            self
        }
        /// <p>The pagination token to use to retrieve the next page of results for this operation. If this value is null, it retrieves the first page.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token to use to retrieve the next page of results for this operation. If this value is null, it retrieves the first page.</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 [`ListWebsiteAuthorizationProvidersOutput`](crate::output::ListWebsiteAuthorizationProvidersOutput)
        pub fn build(self) -> crate::output::ListWebsiteAuthorizationProvidersOutput {
            crate::output::ListWebsiteAuthorizationProvidersOutput {
                website_authorization_providers: self.website_authorization_providers,
                next_token: self.next_token,
            }
        }
    }
}
impl ListWebsiteAuthorizationProvidersOutput {
    /// Creates a new builder-style object to manufacture [`ListWebsiteAuthorizationProvidersOutput`](crate::output::ListWebsiteAuthorizationProvidersOutput)
    pub fn builder() -> crate::output::list_website_authorization_providers_output::Builder {
        crate::output::list_website_authorization_providers_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceOutput {
    /// <p>The tags attached to the resource. A tag is a key-value pair.</p>
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListTagsForResourceOutput {
    /// <p>The tags attached to the resource. A tag is a key-value pair.</p>
    pub fn tags(
        &self,
    ) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
    {
        self.tags.as_ref()
    }
}
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.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::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags attached to the resource. A tag is a key-value pair.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.tags.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.tags = Some(hash_map);
            self
        }
        /// <p>The tags attached to the resource. A tag is a key-value pair.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
        pub fn build(self) -> crate::output::ListTagsForResourceOutput {
            crate::output::ListTagsForResourceOutput { tags: self.tags }
        }
    }
}
impl ListTagsForResourceOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
        crate::output::list_tags_for_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListFleetsOutput {
    /// <p>The summary list of the fleets.</p>
    pub fleet_summary_list: std::option::Option<std::vec::Vec<crate::model::FleetSummary>>,
    /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListFleetsOutput {
    /// <p>The summary list of the fleets.</p>
    pub fn fleet_summary_list(&self) -> std::option::Option<&[crate::model::FleetSummary]> {
        self.fleet_summary_list.as_deref()
    }
    /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListFleetsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListFleetsOutput");
        formatter.field("fleet_summary_list", &self.fleet_summary_list);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListFleetsOutput`](crate::output::ListFleetsOutput)
pub mod list_fleets_output {
    /// A builder for [`ListFleetsOutput`](crate::output::ListFleetsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) fleet_summary_list:
            std::option::Option<std::vec::Vec<crate::model::FleetSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `fleet_summary_list`.
        ///
        /// To override the contents of this collection use [`set_fleet_summary_list`](Self::set_fleet_summary_list).
        ///
        /// <p>The summary list of the fleets.</p>
        pub fn fleet_summary_list(mut self, input: crate::model::FleetSummary) -> Self {
            let mut v = self.fleet_summary_list.unwrap_or_default();
            v.push(input);
            self.fleet_summary_list = Some(v);
            self
        }
        /// <p>The summary list of the fleets.</p>
        pub fn set_fleet_summary_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::FleetSummary>>,
        ) -> Self {
            self.fleet_summary_list = input;
            self
        }
        /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</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 [`ListFleetsOutput`](crate::output::ListFleetsOutput)
        pub fn build(self) -> crate::output::ListFleetsOutput {
            crate::output::ListFleetsOutput {
                fleet_summary_list: self.fleet_summary_list,
                next_token: self.next_token,
            }
        }
    }
}
impl ListFleetsOutput {
    /// Creates a new builder-style object to manufacture [`ListFleetsOutput`](crate::output::ListFleetsOutput)
    pub fn builder() -> crate::output::list_fleets_output::Builder {
        crate::output::list_fleets_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDomainsOutput {
    /// <p>Information about the domains.</p>
    pub domains: std::option::Option<std::vec::Vec<crate::model::DomainSummary>>,
    /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDomainsOutput {
    /// <p>Information about the domains.</p>
    pub fn domains(&self) -> std::option::Option<&[crate::model::DomainSummary]> {
        self.domains.as_deref()
    }
    /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDomainsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDomainsOutput");
        formatter.field("domains", &self.domains);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDomainsOutput`](crate::output::ListDomainsOutput)
pub mod list_domains_output {
    /// A builder for [`ListDomainsOutput`](crate::output::ListDomainsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) domains: std::option::Option<std::vec::Vec<crate::model::DomainSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `domains`.
        ///
        /// To override the contents of this collection use [`set_domains`](Self::set_domains).
        ///
        /// <p>Information about the domains.</p>
        pub fn domains(mut self, input: crate::model::DomainSummary) -> Self {
            let mut v = self.domains.unwrap_or_default();
            v.push(input);
            self.domains = Some(v);
            self
        }
        /// <p>Information about the domains.</p>
        pub fn set_domains(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DomainSummary>>,
        ) -> Self {
            self.domains = input;
            self
        }
        /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</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 [`ListDomainsOutput`](crate::output::ListDomainsOutput)
        pub fn build(self) -> crate::output::ListDomainsOutput {
            crate::output::ListDomainsOutput {
                domains: self.domains,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDomainsOutput {
    /// Creates a new builder-style object to manufacture [`ListDomainsOutput`](crate::output::ListDomainsOutput)
    pub fn builder() -> crate::output::list_domains_output::Builder {
        crate::output::list_domains_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDevicesOutput {
    /// <p>Information about the devices.</p>
    pub devices: std::option::Option<std::vec::Vec<crate::model::DeviceSummary>>,
    /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDevicesOutput {
    /// <p>Information about the devices.</p>
    pub fn devices(&self) -> std::option::Option<&[crate::model::DeviceSummary]> {
        self.devices.as_deref()
    }
    /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDevicesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDevicesOutput");
        formatter.field("devices", &self.devices);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDevicesOutput`](crate::output::ListDevicesOutput)
pub mod list_devices_output {
    /// A builder for [`ListDevicesOutput`](crate::output::ListDevicesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) devices: std::option::Option<std::vec::Vec<crate::model::DeviceSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `devices`.
        ///
        /// To override the contents of this collection use [`set_devices`](Self::set_devices).
        ///
        /// <p>Information about the devices.</p>
        pub fn devices(mut self, input: crate::model::DeviceSummary) -> Self {
            let mut v = self.devices.unwrap_or_default();
            v.push(input);
            self.devices = Some(v);
            self
        }
        /// <p>Information about the devices.</p>
        pub fn set_devices(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DeviceSummary>>,
        ) -> Self {
            self.devices = input;
            self
        }
        /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token used to retrieve the next page of results for this operation. If there are no more pages, this value is null.</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 [`ListDevicesOutput`](crate::output::ListDevicesOutput)
        pub fn build(self) -> crate::output::ListDevicesOutput {
            crate::output::ListDevicesOutput {
                devices: self.devices,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDevicesOutput {
    /// Creates a new builder-style object to manufacture [`ListDevicesOutput`](crate::output::ListDevicesOutput)
    pub fn builder() -> crate::output::list_devices_output::Builder {
        crate::output::list_devices_output::Builder::default()
    }
}

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeWebsiteCertificateAuthorityOutput {
    /// <p>The root certificate of the certificate authority.</p>
    pub certificate: std::option::Option<std::string::String>,
    /// <p>The time that the certificate authority was added.</p>
    pub created_time: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The certificate name to display.</p>
    pub display_name: std::option::Option<std::string::String>,
}
impl DescribeWebsiteCertificateAuthorityOutput {
    /// <p>The root certificate of the certificate authority.</p>
    pub fn certificate(&self) -> std::option::Option<&str> {
        self.certificate.as_deref()
    }
    /// <p>The time that the certificate authority was added.</p>
    pub fn created_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_time.as_ref()
    }
    /// <p>The certificate name to display.</p>
    pub fn display_name(&self) -> std::option::Option<&str> {
        self.display_name.as_deref()
    }
}
impl std::fmt::Debug for DescribeWebsiteCertificateAuthorityOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeWebsiteCertificateAuthorityOutput");
        formatter.field("certificate", &self.certificate);
        formatter.field("created_time", &self.created_time);
        formatter.field("display_name", &self.display_name);
        formatter.finish()
    }
}
/// See [`DescribeWebsiteCertificateAuthorityOutput`](crate::output::DescribeWebsiteCertificateAuthorityOutput)
pub mod describe_website_certificate_authority_output {
    /// A builder for [`DescribeWebsiteCertificateAuthorityOutput`](crate::output::DescribeWebsiteCertificateAuthorityOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) certificate: std::option::Option<std::string::String>,
        pub(crate) created_time: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) display_name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The root certificate of the certificate authority.</p>
        pub fn certificate(mut self, input: impl Into<std::string::String>) -> Self {
            self.certificate = Some(input.into());
            self
        }
        /// <p>The root certificate of the certificate authority.</p>
        pub fn set_certificate(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.certificate = input;
            self
        }
        /// <p>The time that the certificate authority was added.</p>
        pub fn created_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_time = Some(input);
            self
        }
        /// <p>The time that the certificate authority was added.</p>
        pub fn set_created_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_time = input;
            self
        }
        /// <p>The certificate name to display.</p>
        pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.display_name = Some(input.into());
            self
        }
        /// <p>The certificate name to display.</p>
        pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.display_name = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeWebsiteCertificateAuthorityOutput`](crate::output::DescribeWebsiteCertificateAuthorityOutput)
        pub fn build(self) -> crate::output::DescribeWebsiteCertificateAuthorityOutput {
            crate::output::DescribeWebsiteCertificateAuthorityOutput {
                certificate: self.certificate,
                created_time: self.created_time,
                display_name: self.display_name,
            }
        }
    }
}
impl DescribeWebsiteCertificateAuthorityOutput {
    /// Creates a new builder-style object to manufacture [`DescribeWebsiteCertificateAuthorityOutput`](crate::output::DescribeWebsiteCertificateAuthorityOutput)
    pub fn builder() -> crate::output::describe_website_certificate_authority_output::Builder {
        crate::output::describe_website_certificate_authority_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeIdentityProviderConfigurationOutput {
    /// <p>The type of identity provider.</p>
    pub identity_provider_type: std::option::Option<crate::model::IdentityProviderType>,
    /// <p>The SAML metadata document uploaded to the user’s identity provider.</p>
    pub service_provider_saml_metadata: std::option::Option<std::string::String>,
    /// <p>The SAML metadata document provided by the user’s identity provider.</p>
    pub identity_provider_saml_metadata: std::option::Option<std::string::String>,
}
impl DescribeIdentityProviderConfigurationOutput {
    /// <p>The type of identity provider.</p>
    pub fn identity_provider_type(
        &self,
    ) -> std::option::Option<&crate::model::IdentityProviderType> {
        self.identity_provider_type.as_ref()
    }
    /// <p>The SAML metadata document uploaded to the user’s identity provider.</p>
    pub fn service_provider_saml_metadata(&self) -> std::option::Option<&str> {
        self.service_provider_saml_metadata.as_deref()
    }
    /// <p>The SAML metadata document provided by the user’s identity provider.</p>
    pub fn identity_provider_saml_metadata(&self) -> std::option::Option<&str> {
        self.identity_provider_saml_metadata.as_deref()
    }
}
impl std::fmt::Debug for DescribeIdentityProviderConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeIdentityProviderConfigurationOutput");
        formatter.field("identity_provider_type", &self.identity_provider_type);
        formatter.field(
            "service_provider_saml_metadata",
            &self.service_provider_saml_metadata,
        );
        formatter.field(
            "identity_provider_saml_metadata",
            &self.identity_provider_saml_metadata,
        );
        formatter.finish()
    }
}
/// See [`DescribeIdentityProviderConfigurationOutput`](crate::output::DescribeIdentityProviderConfigurationOutput)
pub mod describe_identity_provider_configuration_output {
    /// A builder for [`DescribeIdentityProviderConfigurationOutput`](crate::output::DescribeIdentityProviderConfigurationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) identity_provider_type: std::option::Option<crate::model::IdentityProviderType>,
        pub(crate) service_provider_saml_metadata: std::option::Option<std::string::String>,
        pub(crate) identity_provider_saml_metadata: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The type of identity provider.</p>
        pub fn identity_provider_type(mut self, input: crate::model::IdentityProviderType) -> Self {
            self.identity_provider_type = Some(input);
            self
        }
        /// <p>The type of identity provider.</p>
        pub fn set_identity_provider_type(
            mut self,
            input: std::option::Option<crate::model::IdentityProviderType>,
        ) -> Self {
            self.identity_provider_type = input;
            self
        }
        /// <p>The SAML metadata document uploaded to the user’s identity provider.</p>
        pub fn service_provider_saml_metadata(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.service_provider_saml_metadata = Some(input.into());
            self
        }
        /// <p>The SAML metadata document uploaded to the user’s identity provider.</p>
        pub fn set_service_provider_saml_metadata(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.service_provider_saml_metadata = input;
            self
        }
        /// <p>The SAML metadata document provided by the user’s identity provider.</p>
        pub fn identity_provider_saml_metadata(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.identity_provider_saml_metadata = Some(input.into());
            self
        }
        /// <p>The SAML metadata document provided by the user’s identity provider.</p>
        pub fn set_identity_provider_saml_metadata(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.identity_provider_saml_metadata = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeIdentityProviderConfigurationOutput`](crate::output::DescribeIdentityProviderConfigurationOutput)
        pub fn build(self) -> crate::output::DescribeIdentityProviderConfigurationOutput {
            crate::output::DescribeIdentityProviderConfigurationOutput {
                identity_provider_type: self.identity_provider_type,
                service_provider_saml_metadata: self.service_provider_saml_metadata,
                identity_provider_saml_metadata: self.identity_provider_saml_metadata,
            }
        }
    }
}
impl DescribeIdentityProviderConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`DescribeIdentityProviderConfigurationOutput`](crate::output::DescribeIdentityProviderConfigurationOutput)
    pub fn builder() -> crate::output::describe_identity_provider_configuration_output::Builder {
        crate::output::describe_identity_provider_configuration_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeFleetMetadataOutput {
    /// <p>The time that the fleet was created.</p>
    pub created_time: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The time that the fleet was last updated.</p>
    pub last_updated_time: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The name of the fleet.</p>
    pub fleet_name: std::option::Option<std::string::String>,
    /// <p>The name to display.</p>
    pub display_name: std::option::Option<std::string::String>,
    /// <p>The option to optimize for better performance by routing traffic through the closest AWS Region to users, which may be outside of your home Region.</p>
    pub optimize_for_end_user_location: std::option::Option<bool>,
    /// <p>The identifier used by users to sign in to the Amazon WorkLink app.</p>
    pub company_code: std::option::Option<std::string::String>,
    /// <p>The current state of the fleet.</p>
    pub fleet_status: std::option::Option<crate::model::FleetStatus>,
    /// <p>The tags attached to the resource. A tag is a key-value pair.</p>
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl DescribeFleetMetadataOutput {
    /// <p>The time that the fleet was created.</p>
    pub fn created_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_time.as_ref()
    }
    /// <p>The time that the fleet was last updated.</p>
    pub fn last_updated_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.last_updated_time.as_ref()
    }
    /// <p>The name of the fleet.</p>
    pub fn fleet_name(&self) -> std::option::Option<&str> {
        self.fleet_name.as_deref()
    }
    /// <p>The name to display.</p>
    pub fn display_name(&self) -> std::option::Option<&str> {
        self.display_name.as_deref()
    }
    /// <p>The option to optimize for better performance by routing traffic through the closest AWS Region to users, which may be outside of your home Region.</p>
    pub fn optimize_for_end_user_location(&self) -> std::option::Option<bool> {
        self.optimize_for_end_user_location
    }
    /// <p>The identifier used by users to sign in to the Amazon WorkLink app.</p>
    pub fn company_code(&self) -> std::option::Option<&str> {
        self.company_code.as_deref()
    }
    /// <p>The current state of the fleet.</p>
    pub fn fleet_status(&self) -> std::option::Option<&crate::model::FleetStatus> {
        self.fleet_status.as_ref()
    }
    /// <p>The tags attached to the resource. A tag is a key-value pair.</p>
    pub fn tags(
        &self,
    ) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
    {
        self.tags.as_ref()
    }
}
impl std::fmt::Debug for DescribeFleetMetadataOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeFleetMetadataOutput");
        formatter.field("created_time", &self.created_time);
        formatter.field("last_updated_time", &self.last_updated_time);
        formatter.field("fleet_name", &self.fleet_name);
        formatter.field("display_name", &self.display_name);
        formatter.field(
            "optimize_for_end_user_location",
            &self.optimize_for_end_user_location,
        );
        formatter.field("company_code", &self.company_code);
        formatter.field("fleet_status", &self.fleet_status);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`DescribeFleetMetadataOutput`](crate::output::DescribeFleetMetadataOutput)
pub mod describe_fleet_metadata_output {
    /// A builder for [`DescribeFleetMetadataOutput`](crate::output::DescribeFleetMetadataOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) created_time: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) last_updated_time: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) fleet_name: std::option::Option<std::string::String>,
        pub(crate) display_name: std::option::Option<std::string::String>,
        pub(crate) optimize_for_end_user_location: std::option::Option<bool>,
        pub(crate) company_code: std::option::Option<std::string::String>,
        pub(crate) fleet_status: std::option::Option<crate::model::FleetStatus>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// <p>The time that the fleet was created.</p>
        pub fn created_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_time = Some(input);
            self
        }
        /// <p>The time that the fleet was created.</p>
        pub fn set_created_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_time = input;
            self
        }
        /// <p>The time that the fleet was last updated.</p>
        pub fn last_updated_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.last_updated_time = Some(input);
            self
        }
        /// <p>The time that the fleet was last updated.</p>
        pub fn set_last_updated_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.last_updated_time = input;
            self
        }
        /// <p>The name of the fleet.</p>
        pub fn fleet_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.fleet_name = Some(input.into());
            self
        }
        /// <p>The name of the fleet.</p>
        pub fn set_fleet_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.fleet_name = input;
            self
        }
        /// <p>The name to display.</p>
        pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.display_name = Some(input.into());
            self
        }
        /// <p>The name to display.</p>
        pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.display_name = input;
            self
        }
        /// <p>The option to optimize for better performance by routing traffic through the closest AWS Region to users, which may be outside of your home Region.</p>
        pub fn optimize_for_end_user_location(mut self, input: bool) -> Self {
            self.optimize_for_end_user_location = Some(input);
            self
        }
        /// <p>The option to optimize for better performance by routing traffic through the closest AWS Region to users, which may be outside of your home Region.</p>
        pub fn set_optimize_for_end_user_location(
            mut self,
            input: std::option::Option<bool>,
        ) -> Self {
            self.optimize_for_end_user_location = input;
            self
        }
        /// <p>The identifier used by users to sign in to the Amazon WorkLink app.</p>
        pub fn company_code(mut self, input: impl Into<std::string::String>) -> Self {
            self.company_code = Some(input.into());
            self
        }
        /// <p>The identifier used by users to sign in to the Amazon WorkLink app.</p>
        pub fn set_company_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.company_code = input;
            self
        }
        /// <p>The current state of the fleet.</p>
        pub fn fleet_status(mut self, input: crate::model::FleetStatus) -> Self {
            self.fleet_status = Some(input);
            self
        }
        /// <p>The current state of the fleet.</p>
        pub fn set_fleet_status(
            mut self,
            input: std::option::Option<crate::model::FleetStatus>,
        ) -> Self {
            self.fleet_status = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags attached to the resource. A tag is a key-value pair.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.tags.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.tags = Some(hash_map);
            self
        }
        /// <p>The tags attached to the resource. A tag is a key-value pair.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeFleetMetadataOutput`](crate::output::DescribeFleetMetadataOutput)
        pub fn build(self) -> crate::output::DescribeFleetMetadataOutput {
            crate::output::DescribeFleetMetadataOutput {
                created_time: self.created_time,
                last_updated_time: self.last_updated_time,
                fleet_name: self.fleet_name,
                display_name: self.display_name,
                optimize_for_end_user_location: self.optimize_for_end_user_location,
                company_code: self.company_code,
                fleet_status: self.fleet_status,
                tags: self.tags,
            }
        }
    }
}
impl DescribeFleetMetadataOutput {
    /// Creates a new builder-style object to manufacture [`DescribeFleetMetadataOutput`](crate::output::DescribeFleetMetadataOutput)
    pub fn builder() -> crate::output::describe_fleet_metadata_output::Builder {
        crate::output::describe_fleet_metadata_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeDomainOutput {
    /// <p>The name of the domain.</p>
    pub domain_name: std::option::Option<std::string::String>,
    /// <p>The name to display.</p>
    pub display_name: std::option::Option<std::string::String>,
    /// <p>The time that the domain was added.</p>
    pub created_time: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The current state for the domain.</p>
    pub domain_status: std::option::Option<crate::model::DomainStatus>,
    /// <p>The ARN of an issued ACM certificate that is valid for the domain being associated.</p>
    pub acm_certificate_arn: std::option::Option<std::string::String>,
}
impl DescribeDomainOutput {
    /// <p>The name of the domain.</p>
    pub fn domain_name(&self) -> std::option::Option<&str> {
        self.domain_name.as_deref()
    }
    /// <p>The name to display.</p>
    pub fn display_name(&self) -> std::option::Option<&str> {
        self.display_name.as_deref()
    }
    /// <p>The time that the domain was added.</p>
    pub fn created_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_time.as_ref()
    }
    /// <p>The current state for the domain.</p>
    pub fn domain_status(&self) -> std::option::Option<&crate::model::DomainStatus> {
        self.domain_status.as_ref()
    }
    /// <p>The ARN of an issued ACM certificate that is valid for the domain being associated.</p>
    pub fn acm_certificate_arn(&self) -> std::option::Option<&str> {
        self.acm_certificate_arn.as_deref()
    }
}
impl std::fmt::Debug for DescribeDomainOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeDomainOutput");
        formatter.field("domain_name", &self.domain_name);
        formatter.field("display_name", &self.display_name);
        formatter.field("created_time", &self.created_time);
        formatter.field("domain_status", &self.domain_status);
        formatter.field("acm_certificate_arn", &self.acm_certificate_arn);
        formatter.finish()
    }
}
/// See [`DescribeDomainOutput`](crate::output::DescribeDomainOutput)
pub mod describe_domain_output {
    /// A builder for [`DescribeDomainOutput`](crate::output::DescribeDomainOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) domain_name: std::option::Option<std::string::String>,
        pub(crate) display_name: std::option::Option<std::string::String>,
        pub(crate) created_time: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) domain_status: std::option::Option<crate::model::DomainStatus>,
        pub(crate) acm_certificate_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The name of the domain.</p>
        pub fn domain_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.domain_name = Some(input.into());
            self
        }
        /// <p>The name of the domain.</p>
        pub fn set_domain_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.domain_name = input;
            self
        }
        /// <p>The name to display.</p>
        pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.display_name = Some(input.into());
            self
        }
        /// <p>The name to display.</p>
        pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.display_name = input;
            self
        }
        /// <p>The time that the domain was added.</p>
        pub fn created_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_time = Some(input);
            self
        }
        /// <p>The time that the domain was added.</p>
        pub fn set_created_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_time = input;
            self
        }
        /// <p>The current state for the domain.</p>
        pub fn domain_status(mut self, input: crate::model::DomainStatus) -> Self {
            self.domain_status = Some(input);
            self
        }
        /// <p>The current state for the domain.</p>
        pub fn set_domain_status(
            mut self,
            input: std::option::Option<crate::model::DomainStatus>,
        ) -> Self {
            self.domain_status = input;
            self
        }
        /// <p>The ARN of an issued ACM certificate that is valid for the domain being associated.</p>
        pub fn acm_certificate_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.acm_certificate_arn = Some(input.into());
            self
        }
        /// <p>The ARN of an issued ACM certificate that is valid for the domain being associated.</p>
        pub fn set_acm_certificate_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.acm_certificate_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeDomainOutput`](crate::output::DescribeDomainOutput)
        pub fn build(self) -> crate::output::DescribeDomainOutput {
            crate::output::DescribeDomainOutput {
                domain_name: self.domain_name,
                display_name: self.display_name,
                created_time: self.created_time,
                domain_status: self.domain_status,
                acm_certificate_arn: self.acm_certificate_arn,
            }
        }
    }
}
impl DescribeDomainOutput {
    /// Creates a new builder-style object to manufacture [`DescribeDomainOutput`](crate::output::DescribeDomainOutput)
    pub fn builder() -> crate::output::describe_domain_output::Builder {
        crate::output::describe_domain_output::Builder::default()
    }
}

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeDeviceOutput {
    /// <p>The current state of the device.</p>
    pub status: std::option::Option<crate::model::DeviceStatus>,
    /// <p>The model of the device.</p>
    pub model: std::option::Option<std::string::String>,
    /// <p>The manufacturer of the device.</p>
    pub manufacturer: std::option::Option<std::string::String>,
    /// <p>The operating system of the device.</p>
    pub operating_system: std::option::Option<std::string::String>,
    /// <p>The operating system version of the device.</p>
    pub operating_system_version: std::option::Option<std::string::String>,
    /// <p>The operating system patch level of the device.</p>
    pub patch_level: std::option::Option<std::string::String>,
    /// <p>The date that the device first signed in to Amazon WorkLink.</p>
    pub first_accessed_time: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The date that the device last accessed Amazon WorkLink.</p>
    pub last_accessed_time: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The user name associated with the device.</p>
    pub username: std::option::Option<std::string::String>,
}
impl DescribeDeviceOutput {
    /// <p>The current state of the device.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::DeviceStatus> {
        self.status.as_ref()
    }
    /// <p>The model of the device.</p>
    pub fn model(&self) -> std::option::Option<&str> {
        self.model.as_deref()
    }
    /// <p>The manufacturer of the device.</p>
    pub fn manufacturer(&self) -> std::option::Option<&str> {
        self.manufacturer.as_deref()
    }
    /// <p>The operating system of the device.</p>
    pub fn operating_system(&self) -> std::option::Option<&str> {
        self.operating_system.as_deref()
    }
    /// <p>The operating system version of the device.</p>
    pub fn operating_system_version(&self) -> std::option::Option<&str> {
        self.operating_system_version.as_deref()
    }
    /// <p>The operating system patch level of the device.</p>
    pub fn patch_level(&self) -> std::option::Option<&str> {
        self.patch_level.as_deref()
    }
    /// <p>The date that the device first signed in to Amazon WorkLink.</p>
    pub fn first_accessed_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.first_accessed_time.as_ref()
    }
    /// <p>The date that the device last accessed Amazon WorkLink.</p>
    pub fn last_accessed_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.last_accessed_time.as_ref()
    }
    /// <p>The user name associated with the device.</p>
    pub fn username(&self) -> std::option::Option<&str> {
        self.username.as_deref()
    }
}
impl std::fmt::Debug for DescribeDeviceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeDeviceOutput");
        formatter.field("status", &self.status);
        formatter.field("model", &self.model);
        formatter.field("manufacturer", &self.manufacturer);
        formatter.field("operating_system", &self.operating_system);
        formatter.field("operating_system_version", &self.operating_system_version);
        formatter.field("patch_level", &self.patch_level);
        formatter.field("first_accessed_time", &self.first_accessed_time);
        formatter.field("last_accessed_time", &self.last_accessed_time);
        formatter.field("username", &self.username);
        formatter.finish()
    }
}
/// See [`DescribeDeviceOutput`](crate::output::DescribeDeviceOutput)
pub mod describe_device_output {
    /// A builder for [`DescribeDeviceOutput`](crate::output::DescribeDeviceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::DeviceStatus>,
        pub(crate) model: std::option::Option<std::string::String>,
        pub(crate) manufacturer: std::option::Option<std::string::String>,
        pub(crate) operating_system: std::option::Option<std::string::String>,
        pub(crate) operating_system_version: std::option::Option<std::string::String>,
        pub(crate) patch_level: std::option::Option<std::string::String>,
        pub(crate) first_accessed_time: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) last_accessed_time: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) username: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The current state of the device.</p>
        pub fn status(mut self, input: crate::model::DeviceStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>The current state of the device.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::DeviceStatus>,
        ) -> Self {
            self.status = input;
            self
        }
        /// <p>The model of the device.</p>
        pub fn model(mut self, input: impl Into<std::string::String>) -> Self {
            self.model = Some(input.into());
            self
        }
        /// <p>The model of the device.</p>
        pub fn set_model(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.model = input;
            self
        }
        /// <p>The manufacturer of the device.</p>
        pub fn manufacturer(mut self, input: impl Into<std::string::String>) -> Self {
            self.manufacturer = Some(input.into());
            self
        }
        /// <p>The manufacturer of the device.</p>
        pub fn set_manufacturer(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.manufacturer = input;
            self
        }
        /// <p>The operating system of the device.</p>
        pub fn operating_system(mut self, input: impl Into<std::string::String>) -> Self {
            self.operating_system = Some(input.into());
            self
        }
        /// <p>The operating system of the device.</p>
        pub fn set_operating_system(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.operating_system = input;
            self
        }
        /// <p>The operating system version of the device.</p>
        pub fn operating_system_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.operating_system_version = Some(input.into());
            self
        }
        /// <p>The operating system version of the device.</p>
        pub fn set_operating_system_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.operating_system_version = input;
            self
        }
        /// <p>The operating system patch level of the device.</p>
        pub fn patch_level(mut self, input: impl Into<std::string::String>) -> Self {
            self.patch_level = Some(input.into());
            self
        }
        /// <p>The operating system patch level of the device.</p>
        pub fn set_patch_level(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.patch_level = input;
            self
        }
        /// <p>The date that the device first signed in to Amazon WorkLink.</p>
        pub fn first_accessed_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.first_accessed_time = Some(input);
            self
        }
        /// <p>The date that the device first signed in to Amazon WorkLink.</p>
        pub fn set_first_accessed_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.first_accessed_time = input;
            self
        }
        /// <p>The date that the device last accessed Amazon WorkLink.</p>
        pub fn last_accessed_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.last_accessed_time = Some(input);
            self
        }
        /// <p>The date that the device last accessed Amazon WorkLink.</p>
        pub fn set_last_accessed_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.last_accessed_time = input;
            self
        }
        /// <p>The user name associated with the device.</p>
        pub fn username(mut self, input: impl Into<std::string::String>) -> Self {
            self.username = Some(input.into());
            self
        }
        /// <p>The user name associated with the device.</p>
        pub fn set_username(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.username = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeDeviceOutput`](crate::output::DescribeDeviceOutput)
        pub fn build(self) -> crate::output::DescribeDeviceOutput {
            crate::output::DescribeDeviceOutput {
                status: self.status,
                model: self.model,
                manufacturer: self.manufacturer,
                operating_system: self.operating_system,
                operating_system_version: self.operating_system_version,
                patch_level: self.patch_level,
                first_accessed_time: self.first_accessed_time,
                last_accessed_time: self.last_accessed_time,
                username: self.username,
            }
        }
    }
}
impl DescribeDeviceOutput {
    /// Creates a new builder-style object to manufacture [`DescribeDeviceOutput`](crate::output::DescribeDeviceOutput)
    pub fn builder() -> crate::output::describe_device_output::Builder {
        crate::output::describe_device_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeCompanyNetworkConfigurationOutput {
    /// <p>The VPC with connectivity to associated websites.</p>
    pub vpc_id: std::option::Option<std::string::String>,
    /// <p>The subnets used for X-ENI connections from Amazon WorkLink rendering containers.</p>
    pub subnet_ids: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The security groups associated with access to the provided subnets.</p>
    pub security_group_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl DescribeCompanyNetworkConfigurationOutput {
    /// <p>The VPC with connectivity to associated websites.</p>
    pub fn vpc_id(&self) -> std::option::Option<&str> {
        self.vpc_id.as_deref()
    }
    /// <p>The subnets used for X-ENI connections from Amazon WorkLink rendering containers.</p>
    pub fn subnet_ids(&self) -> std::option::Option<&[std::string::String]> {
        self.subnet_ids.as_deref()
    }
    /// <p>The security groups associated with access to the provided subnets.</p>
    pub fn security_group_ids(&self) -> std::option::Option<&[std::string::String]> {
        self.security_group_ids.as_deref()
    }
}
impl std::fmt::Debug for DescribeCompanyNetworkConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeCompanyNetworkConfigurationOutput");
        formatter.field("vpc_id", &self.vpc_id);
        formatter.field("subnet_ids", &self.subnet_ids);
        formatter.field("security_group_ids", &self.security_group_ids);
        formatter.finish()
    }
}
/// See [`DescribeCompanyNetworkConfigurationOutput`](crate::output::DescribeCompanyNetworkConfigurationOutput)
pub mod describe_company_network_configuration_output {
    /// A builder for [`DescribeCompanyNetworkConfigurationOutput`](crate::output::DescribeCompanyNetworkConfigurationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) vpc_id: std::option::Option<std::string::String>,
        pub(crate) subnet_ids: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) security_group_ids: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        /// <p>The VPC with connectivity to associated websites.</p>
        pub fn vpc_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.vpc_id = Some(input.into());
            self
        }
        /// <p>The VPC with connectivity to associated websites.</p>
        pub fn set_vpc_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.vpc_id = input;
            self
        }
        /// Appends an item to `subnet_ids`.
        ///
        /// To override the contents of this collection use [`set_subnet_ids`](Self::set_subnet_ids).
        ///
        /// <p>The subnets used for X-ENI connections from Amazon WorkLink rendering containers.</p>
        pub fn subnet_ids(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.subnet_ids.unwrap_or_default();
            v.push(input.into());
            self.subnet_ids = Some(v);
            self
        }
        /// <p>The subnets used for X-ENI connections from Amazon WorkLink rendering containers.</p>
        pub fn set_subnet_ids(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.subnet_ids = input;
            self
        }
        /// Appends an item to `security_group_ids`.
        ///
        /// To override the contents of this collection use [`set_security_group_ids`](Self::set_security_group_ids).
        ///
        /// <p>The security groups associated with access to the provided subnets.</p>
        pub fn security_group_ids(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.security_group_ids.unwrap_or_default();
            v.push(input.into());
            self.security_group_ids = Some(v);
            self
        }
        /// <p>The security groups associated with access to the provided subnets.</p>
        pub fn set_security_group_ids(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.security_group_ids = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeCompanyNetworkConfigurationOutput`](crate::output::DescribeCompanyNetworkConfigurationOutput)
        pub fn build(self) -> crate::output::DescribeCompanyNetworkConfigurationOutput {
            crate::output::DescribeCompanyNetworkConfigurationOutput {
                vpc_id: self.vpc_id,
                subnet_ids: self.subnet_ids,
                security_group_ids: self.security_group_ids,
            }
        }
    }
}
impl DescribeCompanyNetworkConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`DescribeCompanyNetworkConfigurationOutput`](crate::output::DescribeCompanyNetworkConfigurationOutput)
    pub fn builder() -> crate::output::describe_company_network_configuration_output::Builder {
        crate::output::describe_company_network_configuration_output::Builder::default()
    }
}

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

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

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

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

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

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